From e6fe40929f2de460e9ba896ef559a3a16e232ffd Mon Sep 17 00:00:00 2001 From: Erik Ovegard Date: Tue, 23 Feb 2016 11:00:18 +0100 Subject: [PATCH 1/5] Added "nullable" static constructors --- .../GeneratedCode/AccelerationTestsBase.g.cs | 15 + .../AmplitudeRatioTestsBase.g.cs | 15 + .../GeneratedCode/AngleTestsBase.g.cs | 15 + .../GeneratedCode/AreaTestsBase.g.cs | 15 + .../GeneratedCode/DensityTestsBase.g.cs | 15 + .../GeneratedCode/DurationTestsBase.g.cs | 15 + .../ElectricCurrentTestsBase.g.cs | 15 + .../ElectricPotentialTestsBase.g.cs | 15 + .../ElectricResistanceTestsBase.g.cs | 15 + .../GeneratedCode/EnergyTestsBase.g.cs | 15 + .../GeneratedCode/FlowTestsBase.g.cs | 15 + .../ForceChangeRateTestsBase.g.cs | 15 + .../GeneratedCode/ForceTestsBase.g.cs | 15 + .../GeneratedCode/FrequencyTestsBase.g.cs | 15 + .../GeneratedCode/InformationTestsBase.g.cs | 15 + .../KinematicViscosityTestsBase.g.cs | 15 + .../GeneratedCode/LengthTestsBase.g.cs | 15 + .../GeneratedCode/LevelTestsBase.g.cs | 15 + .../GeneratedCode/MassFlowTestsBase.g.cs | 15 + .../GeneratedCode/MassTestsBase.g.cs | 15 + .../GeneratedCode/PowerRatioTestsBase.g.cs | 15 + .../GeneratedCode/PowerTestsBase.g.cs | 15 + .../PressureChangeRateTestsBase.g.cs | 15 + .../GeneratedCode/PressureTestsBase.g.cs | 15 + .../GeneratedCode/RatioTestsBase.g.cs | 15 + .../RotationalSpeedTestsBase.g.cs | 15 + .../SpecificEnergyTestsBase.g.cs | 15 + .../SpecificWeightTestsBase.g.cs | 15 + .../GeneratedCode/SpeedTestsBase.g.cs | 15 + .../TemperatureChangeRateTestsBase.g.cs | 15 + .../GeneratedCode/TemperatureTestsBase.g.cs | 15 + .../GeneratedCode/TorqueTestsBase.g.cs | 15 + .../GeneratedCode/VitaminATestsBase.g.cs | 15 + .../GeneratedCode/VolumeTestsBase.g.cs | 15 + .../UnitClasses/Acceleration.g.cs | 106 ++++ .../UnitClasses/AmplitudeRatio.g.cs | 46 ++ UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs | 151 ++++++ UnitsNet/GeneratedCode/UnitClasses/Area.g.cs | 151 ++++++ .../GeneratedCode/UnitClasses/Density.g.cs | 151 ++++++ .../GeneratedCode/UnitClasses/Duration.g.cs | 151 ++++++ .../UnitClasses/ElectricCurrent.g.cs | 91 ++++ .../UnitClasses/ElectricPotential.g.cs | 76 +++ .../UnitClasses/ElectricResistance.g.cs | 46 ++ .../GeneratedCode/UnitClasses/Energy.g.cs | 196 +++++++ UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs | 91 ++++ UnitsNet/GeneratedCode/UnitClasses/Force.g.cs | 121 +++++ .../UnitClasses/ForceChangeRate.g.cs | 16 + .../GeneratedCode/UnitClasses/Frequency.g.cs | 121 +++++ .../UnitClasses/Information.g.cs | 391 ++++++++++++++ .../UnitClasses/KinematicViscosity.g.cs | 121 +++++ .../GeneratedCode/UnitClasses/Length.g.cs | 211 ++++++++ UnitsNet/GeneratedCode/UnitClasses/Level.g.cs | 31 ++ UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs | 256 +++++++++ .../GeneratedCode/UnitClasses/MassFlow.g.cs | 151 ++++++ UnitsNet/GeneratedCode/UnitClasses/Power.g.cs | 241 +++++++++ .../GeneratedCode/UnitClasses/PowerRatio.g.cs | 31 ++ .../GeneratedCode/UnitClasses/Pressure.g.cs | 496 ++++++++++++++++++ .../UnitClasses/PressureChangeRate.g.cs | 61 +++ UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs | 91 ++++ .../UnitClasses/RotationalSpeed.g.cs | 121 +++++ .../UnitClasses/SpecificEnergy.g.cs | 121 +++++ .../UnitClasses/SpecificWeight.g.cs | 241 +++++++++ UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs | 181 +++++++ .../UnitClasses/Temperature.g.cs | 121 +++++ .../UnitClasses/TemperatureChangeRate.g.cs | 136 +++++ .../GeneratedCode/UnitClasses/Torque.g.cs | 241 +++++++++ .../GeneratedCode/UnitClasses/VitaminA.g.cs | 16 + .../GeneratedCode/UnitClasses/Volume.g.cs | 436 +++++++++++++++ .../Include-GenerateUnitClassSourceCode.ps1 | 28 +- ...de-GenerateUnitTestBaseClassSourceCode.ps1 | 15 + 70 files changed, 5758 insertions(+), 4 deletions(-) diff --git a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs index e55a0044a4..10ffd9a633 100644 --- a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs @@ -199,5 +199,20 @@ public void EqualsReturnsFalseOnNull() Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1); Assert.IsFalse(meterpersecondsquared.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Acceleration? meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(null); + Assert.IsTrue(meterpersecondsquared.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Acceleration? meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(value); + Assert.IsTrue(meterpersecondsquared.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs index 786dcee38d..41aaf1a656 100644 --- a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs @@ -179,5 +179,20 @@ public void EqualsReturnsFalseOnNull() AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1); Assert.IsFalse(decibelvolt.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + AmplitudeRatio? decibelvolt = AmplitudeRatio.FromDecibelVolts(null); + Assert.IsTrue(decibelvolt.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + AmplitudeRatio? decibelvolt = AmplitudeRatio.FromDecibelVolts(value); + Assert.IsTrue(decibelvolt.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs index d330008fcc..4c8d196adb 100644 --- a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs @@ -217,5 +217,20 @@ public void EqualsReturnsFalseOnNull() Angle degree = Angle.FromDegrees(1); Assert.IsFalse(degree.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Angle? degree = Angle.FromDegrees(null); + Assert.IsTrue(degree.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Angle? degree = Angle.FromDegrees(value); + Assert.IsTrue(degree.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs index ada71764bf..b4b35fada2 100644 --- a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs @@ -217,5 +217,20 @@ public void EqualsReturnsFalseOnNull() Area squaremeter = Area.FromSquareMeters(1); Assert.IsFalse(squaremeter.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Area? squaremeter = Area.FromSquareMeters(null); + Assert.IsTrue(squaremeter.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Area? squaremeter = Area.FromSquareMeters(value); + Assert.IsTrue(squaremeter.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs index 87a39ad9c6..a7380475df 100644 --- a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs @@ -217,5 +217,20 @@ public void EqualsReturnsFalseOnNull() Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1); Assert.IsFalse(kilogrampercubicmeter.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Density? kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(null); + Assert.IsTrue(kilogrampercubicmeter.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Density? kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(value); + Assert.IsTrue(kilogrampercubicmeter.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs index 3b134a6b08..285cc6ba9c 100644 --- a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs @@ -217,5 +217,20 @@ public void EqualsReturnsFalseOnNull() Duration second = Duration.FromSeconds(1); Assert.IsFalse(second.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Duration? second = Duration.FromSeconds(null); + Assert.IsTrue(second.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Duration? second = Duration.FromSeconds(value); + Assert.IsTrue(second.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs index 52f03bd23f..e8e8d766ec 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs @@ -193,5 +193,20 @@ public void EqualsReturnsFalseOnNull() ElectricCurrent ampere = ElectricCurrent.FromAmperes(1); Assert.IsFalse(ampere.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + ElectricCurrent? ampere = ElectricCurrent.FromAmperes(null); + Assert.IsTrue(ampere.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + ElectricCurrent? ampere = ElectricCurrent.FromAmperes(value); + Assert.IsTrue(ampere.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs index 319f56cacc..ee57c93cc7 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs @@ -187,5 +187,20 @@ public void EqualsReturnsFalseOnNull() ElectricPotential volt = ElectricPotential.FromVolts(1); Assert.IsFalse(volt.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + ElectricPotential? volt = ElectricPotential.FromVolts(null); + Assert.IsTrue(volt.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + ElectricPotential? volt = ElectricPotential.FromVolts(value); + Assert.IsTrue(volt.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs index a23d9028c1..29995547c6 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs @@ -175,5 +175,20 @@ public void EqualsReturnsFalseOnNull() ElectricResistance ohm = ElectricResistance.FromOhms(1); Assert.IsFalse(ohm.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + ElectricResistance? ohm = ElectricResistance.FromOhms(null); + Assert.IsTrue(ohm.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + ElectricResistance? ohm = ElectricResistance.FromOhms(value); + Assert.IsTrue(ohm.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs index e23f86a521..d9caf1c72f 100644 --- a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs @@ -235,5 +235,20 @@ public void EqualsReturnsFalseOnNull() Energy joule = Energy.FromJoules(1); Assert.IsFalse(joule.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Energy? joule = Energy.FromJoules(null); + Assert.IsTrue(joule.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Energy? joule = Energy.FromJoules(value); + Assert.IsTrue(joule.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs index 8287346863..8401c492da 100644 --- a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs @@ -193,5 +193,20 @@ public void EqualsReturnsFalseOnNull() Flow cubicmeterpersecond = Flow.FromCubicMetersPerSecond(1); Assert.IsFalse(cubicmeterpersecond.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Flow? cubicmeterpersecond = Flow.FromCubicMetersPerSecond(null); + Assert.IsTrue(cubicmeterpersecond.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Flow? cubicmeterpersecond = Flow.FromCubicMetersPerSecond(value); + Assert.IsTrue(cubicmeterpersecond.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs index c521f78f26..aa23722991 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs @@ -163,5 +163,20 @@ public void EqualsReturnsFalseOnNull() ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1); Assert.IsFalse(newtonpersecond.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + ForceChangeRate? newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(null); + Assert.IsTrue(newtonpersecond.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + ForceChangeRate? newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(value); + Assert.IsTrue(newtonpersecond.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs index 94a60dbe77..edbbbab988 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs @@ -205,5 +205,20 @@ public void EqualsReturnsFalseOnNull() Force newton = Force.FromNewtons(1); Assert.IsFalse(newton.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Force? newton = Force.FromNewtons(null); + Assert.IsTrue(newton.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Force? newton = Force.FromNewtons(value); + Assert.IsTrue(newton.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs index c01b961863..b4325faba3 100644 --- a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs @@ -205,5 +205,20 @@ public void EqualsReturnsFalseOnNull() Frequency hertz = Frequency.FromHertz(1); Assert.IsFalse(hertz.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Frequency? hertz = Frequency.FromHertz(null); + Assert.IsTrue(hertz.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Frequency? hertz = Frequency.FromHertz(value); + Assert.IsTrue(hertz.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs index f740691f61..878731d684 100644 --- a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs @@ -313,5 +313,20 @@ public void EqualsReturnsFalseOnNull() Information bit = Information.FromBits(1); Assert.IsFalse(bit.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Information? bit = Information.FromBits(null); + Assert.IsTrue(bit.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Information? bit = Information.FromBits(value); + Assert.IsTrue(bit.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs index b22eb12e06..96541fa0dc 100644 --- a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs @@ -205,5 +205,20 @@ public void EqualsReturnsFalseOnNull() KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1); Assert.IsFalse(squaremeterpersecond.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + KinematicViscosity? squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(null); + Assert.IsTrue(squaremeterpersecond.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + KinematicViscosity? squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(value); + Assert.IsTrue(squaremeterpersecond.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs index a247b5798b..59c329c67d 100644 --- a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs @@ -241,5 +241,20 @@ public void EqualsReturnsFalseOnNull() Length meter = Length.FromMeters(1); Assert.IsFalse(meter.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Length? meter = Length.FromMeters(null); + Assert.IsTrue(meter.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Length? meter = Length.FromMeters(value); + Assert.IsTrue(meter.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs index dac295d95d..b30ed68352 100644 --- a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs @@ -173,5 +173,20 @@ public void EqualsReturnsFalseOnNull() Level decibel = Level.FromDecibels(1); Assert.IsFalse(decibel.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Level? decibel = Level.FromDecibels(null); + Assert.IsTrue(decibel.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Level? decibel = Level.FromDecibels(value); + Assert.IsTrue(decibel.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs index 583c7cf5dc..3b4bff1124 100644 --- a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs @@ -217,5 +217,20 @@ public void EqualsReturnsFalseOnNull() MassFlow grampersecond = MassFlow.FromGramsPerSecond(1); Assert.IsFalse(grampersecond.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + MassFlow? grampersecond = MassFlow.FromGramsPerSecond(null); + Assert.IsTrue(grampersecond.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + MassFlow? grampersecond = MassFlow.FromGramsPerSecond(value); + Assert.IsTrue(grampersecond.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs index 7775d245e0..7d48a6b953 100644 --- a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs @@ -259,5 +259,20 @@ public void EqualsReturnsFalseOnNull() Mass kilogram = Mass.FromKilograms(1); Assert.IsFalse(kilogram.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Mass? kilogram = Mass.FromKilograms(null); + Assert.IsTrue(kilogram.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Mass? kilogram = Mass.FromKilograms(value); + Assert.IsTrue(kilogram.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs index 4c505d6c08..ac8ce52acf 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs @@ -173,5 +173,20 @@ public void EqualsReturnsFalseOnNull() PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1); Assert.IsFalse(decibelwatt.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + PowerRatio? decibelwatt = PowerRatio.FromDecibelWatts(null); + Assert.IsTrue(decibelwatt.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + PowerRatio? decibelwatt = PowerRatio.FromDecibelWatts(value); + Assert.IsTrue(decibelwatt.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs index 221ceaf04f..154a1c999b 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs @@ -253,5 +253,20 @@ public void EqualsReturnsFalseOnNull() Power watt = Power.FromWatts(1); Assert.IsFalse(watt.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Power? watt = Power.FromWatts(null); + Assert.IsTrue(watt.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Power? watt = Power.FromWatts(value); + Assert.IsTrue(watt.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs index f9200bb56a..aa4fab3bad 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs @@ -181,5 +181,20 @@ public void EqualsReturnsFalseOnNull() PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1); Assert.IsFalse(pascalpersecond.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + PressureChangeRate? pascalpersecond = PressureChangeRate.FromPascalsPerSecond(null); + Assert.IsTrue(pascalpersecond.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + PressureChangeRate? pascalpersecond = PressureChangeRate.FromPascalsPerSecond(value); + Assert.IsTrue(pascalpersecond.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs index cf3b489a71..6e2c3e906f 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs @@ -355,5 +355,20 @@ public void EqualsReturnsFalseOnNull() Pressure pascal = Pressure.FromPascals(1); Assert.IsFalse(pascal.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Pressure? pascal = Pressure.FromPascals(null); + Assert.IsTrue(pascal.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Pressure? pascal = Pressure.FromPascals(value); + Assert.IsTrue(pascal.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs index 212682834e..4c6d82ff45 100644 --- a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs @@ -193,5 +193,20 @@ public void EqualsReturnsFalseOnNull() Ratio decimalfraction = Ratio.FromDecimalFractions(1); Assert.IsFalse(decimalfraction.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Ratio? decimalfraction = Ratio.FromDecimalFractions(null); + Assert.IsTrue(decimalfraction.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Ratio? decimalfraction = Ratio.FromDecimalFractions(value); + Assert.IsTrue(decimalfraction.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs index 552412d898..45b86fc263 100644 --- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs @@ -205,5 +205,20 @@ public void EqualsReturnsFalseOnNull() RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); Assert.IsFalse(radianpersecond.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + RotationalSpeed? radianpersecond = RotationalSpeed.FromRadiansPerSecond(null); + Assert.IsTrue(radianpersecond.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + RotationalSpeed? radianpersecond = RotationalSpeed.FromRadiansPerSecond(value); + Assert.IsTrue(radianpersecond.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs index 7a5ba37b27..8bd167a3ca 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs @@ -205,5 +205,20 @@ public void EqualsReturnsFalseOnNull() SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1); Assert.IsFalse(jouleperkilogram.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + SpecificEnergy? jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(null); + Assert.IsTrue(jouleperkilogram.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + SpecificEnergy? jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(value); + Assert.IsTrue(jouleperkilogram.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs index 52535a75d2..281c71c1cc 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs @@ -253,5 +253,20 @@ public void EqualsReturnsFalseOnNull() SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1); Assert.IsFalse(newtonpercubicmeter.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + SpecificWeight? newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(null); + Assert.IsTrue(newtonpercubicmeter.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + SpecificWeight? newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(value); + Assert.IsTrue(newtonpercubicmeter.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs index c87c6c8bb8..83776fd793 100644 --- a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs @@ -229,5 +229,20 @@ public void EqualsReturnsFalseOnNull() Speed meterpersecond = Speed.FromMetersPerSecond(1); Assert.IsFalse(meterpersecond.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Speed? meterpersecond = Speed.FromMetersPerSecond(null); + Assert.IsTrue(meterpersecond.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Speed? meterpersecond = Speed.FromMetersPerSecond(value); + Assert.IsTrue(meterpersecond.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs index e5b1a8daf6..cac74d03f6 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs @@ -211,5 +211,20 @@ public void EqualsReturnsFalseOnNull() TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1); Assert.IsFalse(degreecelsiuspersecond.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + TemperatureChangeRate? degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(null); + Assert.IsTrue(degreecelsiuspersecond.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + TemperatureChangeRate? degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(value); + Assert.IsTrue(degreecelsiuspersecond.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs index 874ea01916..3c13f14cc9 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs @@ -205,5 +205,20 @@ public void EqualsReturnsFalseOnNull() Temperature kelvin = Temperature.FromKelvins(1); Assert.IsFalse(kelvin.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Temperature? kelvin = Temperature.FromKelvins(null); + Assert.IsTrue(kelvin.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Temperature? kelvin = Temperature.FromKelvins(value); + Assert.IsTrue(kelvin.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs index 8b7469ba75..99e6f82678 100644 --- a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs @@ -253,5 +253,20 @@ public void EqualsReturnsFalseOnNull() Torque newtonmeter = Torque.FromNewtonMeters(1); Assert.IsFalse(newtonmeter.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Torque? newtonmeter = Torque.FromNewtonMeters(null); + Assert.IsTrue(newtonmeter.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Torque? newtonmeter = Torque.FromNewtonMeters(value); + Assert.IsTrue(newtonmeter.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs index f6c0f92814..0e9cf4d3a2 100644 --- a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs @@ -163,5 +163,20 @@ public void EqualsReturnsFalseOnNull() VitaminA internationalunit = VitaminA.FromInternationalUnits(1); Assert.IsFalse(internationalunit.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + VitaminA? internationalunit = VitaminA.FromInternationalUnits(null); + Assert.IsTrue(internationalunit.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + VitaminA? internationalunit = VitaminA.FromInternationalUnits(value); + Assert.IsTrue(internationalunit.HasValue); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs index 35297ebd61..1ffa990ac2 100644 --- a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs @@ -331,5 +331,20 @@ public void EqualsReturnsFalseOnNull() Volume cubicmeter = Volume.FromCubicMeters(1); Assert.IsFalse(cubicmeter.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + Volume? cubicmeter = Volume.FromCubicMeters(null); + Assert.IsTrue(cubicmeter.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Volume? cubicmeter = Volume.FromCubicMeters(value); + Assert.IsTrue(cubicmeter.HasValue); + } } } diff --git a/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs index 1b53030d48..ca83e28819 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs @@ -176,6 +176,112 @@ public static Acceleration FromNanometerPerSecondSquared(double nanometerperseco } + /// + /// Get nullable Acceleration from nullable CentimeterPerSecondSquared. + /// + public static Acceleration? FromCentimeterPerSecondSquared(double? centimeterpersecondsquared) + { + if (centimeterpersecondsquared.HasValue) + { + return new Acceleration((centimeterpersecondsquared.Value) * 1e-2d); + } + else + { + return null; + } + } + + /// + /// Get nullable Acceleration from nullable DecimeterPerSecondSquared. + /// + public static Acceleration? FromDecimeterPerSecondSquared(double? decimeterpersecondsquared) + { + if (decimeterpersecondsquared.HasValue) + { + return new Acceleration((decimeterpersecondsquared.Value) * 1e-1d); + } + else + { + return null; + } + } + + /// + /// Get nullable Acceleration from nullable KilometerPerSecondSquared. + /// + public static Acceleration? FromKilometerPerSecondSquared(double? kilometerpersecondsquared) + { + if (kilometerpersecondsquared.HasValue) + { + return new Acceleration((kilometerpersecondsquared.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Acceleration from nullable MeterPerSecondSquared. + /// + public static Acceleration? FromMeterPerSecondSquared(double? meterpersecondsquared) + { + if (meterpersecondsquared.HasValue) + { + return new Acceleration(meterpersecondsquared.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Acceleration from nullable MicrometerPerSecondSquared. + /// + public static Acceleration? FromMicrometerPerSecondSquared(double? micrometerpersecondsquared) + { + if (micrometerpersecondsquared.HasValue) + { + return new Acceleration((micrometerpersecondsquared.Value) * 1e-6d); + } + else + { + return null; + } + } + + /// + /// Get nullable Acceleration from nullable MillimeterPerSecondSquared. + /// + public static Acceleration? FromMillimeterPerSecondSquared(double? millimeterpersecondsquared) + { + if (millimeterpersecondsquared.HasValue) + { + return new Acceleration((millimeterpersecondsquared.Value) * 1e-3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Acceleration from nullable NanometerPerSecondSquared. + /// + public static Acceleration? FromNanometerPerSecondSquared(double? nanometerpersecondsquared) + { + if (nanometerpersecondsquared.HasValue) + { + return new Acceleration((nanometerpersecondsquared.Value) * 1e-9d); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs index 8b7b8340e5..40a7ee2ab8 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs @@ -112,6 +112,52 @@ public static AmplitudeRatio FromDecibelVolts(double decibelvolts) } + /// + /// Get nullable AmplitudeRatio from nullable DecibelMicrovolts. + /// + public static AmplitudeRatio? FromDecibelMicrovolts(double? decibelmicrovolts) + { + if (decibelmicrovolts.HasValue) + { + return new AmplitudeRatio(decibelmicrovolts.Value - 120); + } + else + { + return null; + } + } + + /// + /// Get nullable AmplitudeRatio from nullable DecibelMillivolts. + /// + public static AmplitudeRatio? FromDecibelMillivolts(double? decibelmillivolts) + { + if (decibelmillivolts.HasValue) + { + return new AmplitudeRatio(decibelmillivolts.Value - 60); + } + else + { + return null; + } + } + + /// + /// Get nullable AmplitudeRatio from nullable DecibelVolts. + /// + public static AmplitudeRatio? FromDecibelVolts(double? decibelvolts) + { + if (decibelvolts.HasValue) + { + return new AmplitudeRatio(decibelvolts.Value); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs index cdd3d974bc..8fdc2e5831 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs @@ -224,6 +224,157 @@ public static Angle FromRadians(double radians) } + /// + /// Get nullable Angle from nullable Arcminutes. + /// + public static Angle? FromArcminutes(double? arcminutes) + { + if (arcminutes.HasValue) + { + return new Angle(arcminutes.Value/60); + } + else + { + return null; + } + } + + /// + /// Get nullable Angle from nullable Arcseconds. + /// + public static Angle? FromArcseconds(double? arcseconds) + { + if (arcseconds.HasValue) + { + return new Angle(arcseconds.Value/3600); + } + else + { + return null; + } + } + + /// + /// Get nullable Angle from nullable Centiradians. + /// + public static Angle? FromCentiradians(double? centiradians) + { + if (centiradians.HasValue) + { + return new Angle((centiradians.Value*180/Math.PI) * 1e-2d); + } + else + { + return null; + } + } + + /// + /// Get nullable Angle from nullable Deciradians. + /// + public static Angle? FromDeciradians(double? deciradians) + { + if (deciradians.HasValue) + { + return new Angle((deciradians.Value*180/Math.PI) * 1e-1d); + } + else + { + return null; + } + } + + /// + /// Get nullable Angle from nullable Degrees. + /// + public static Angle? FromDegrees(double? degrees) + { + if (degrees.HasValue) + { + return new Angle(degrees.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Angle from nullable Gradians. + /// + public static Angle? FromGradians(double? gradians) + { + if (gradians.HasValue) + { + return new Angle(gradians.Value*0.9); + } + else + { + return null; + } + } + + /// + /// Get nullable Angle from nullable Microradians. + /// + public static Angle? FromMicroradians(double? microradians) + { + if (microradians.HasValue) + { + return new Angle((microradians.Value*180/Math.PI) * 1e-6d); + } + else + { + return null; + } + } + + /// + /// Get nullable Angle from nullable Milliradians. + /// + public static Angle? FromMilliradians(double? milliradians) + { + if (milliradians.HasValue) + { + return new Angle((milliradians.Value*180/Math.PI) * 1e-3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Angle from nullable Nanoradians. + /// + public static Angle? FromNanoradians(double? nanoradians) + { + if (nanoradians.HasValue) + { + return new Angle((nanoradians.Value*180/Math.PI) * 1e-9d); + } + else + { + return null; + } + } + + /// + /// Get nullable Angle from nullable Radians. + /// + public static Angle? FromRadians(double? radians) + { + if (radians.HasValue) + { + return new Angle(radians.Value*180/Math.PI); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs index 5cb78c55e1..315ea9caff 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs @@ -224,6 +224,157 @@ public static Area FromSquareYards(double squareyards) } + /// + /// Get nullable Area from nullable SquareCentimeters. + /// + public static Area? FromSquareCentimeters(double? squarecentimeters) + { + if (squarecentimeters.HasValue) + { + return new Area(squarecentimeters.Value*1e-4); + } + else + { + return null; + } + } + + /// + /// Get nullable Area from nullable SquareDecimeters. + /// + public static Area? FromSquareDecimeters(double? squaredecimeters) + { + if (squaredecimeters.HasValue) + { + return new Area(squaredecimeters.Value*1e-2); + } + else + { + return null; + } + } + + /// + /// Get nullable Area from nullable SquareFeet. + /// + public static Area? FromSquareFeet(double? squarefeet) + { + if (squarefeet.HasValue) + { + return new Area(squarefeet.Value*0.092903); + } + else + { + return null; + } + } + + /// + /// Get nullable Area from nullable SquareInches. + /// + public static Area? FromSquareInches(double? squareinches) + { + if (squareinches.HasValue) + { + return new Area(squareinches.Value*0.00064516); + } + else + { + return null; + } + } + + /// + /// Get nullable Area from nullable SquareKilometers. + /// + public static Area? FromSquareKilometers(double? squarekilometers) + { + if (squarekilometers.HasValue) + { + return new Area(squarekilometers.Value*1e6); + } + else + { + return null; + } + } + + /// + /// Get nullable Area from nullable SquareMeters. + /// + public static Area? FromSquareMeters(double? squaremeters) + { + if (squaremeters.HasValue) + { + return new Area(squaremeters.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Area from nullable SquareMicrometers. + /// + public static Area? FromSquareMicrometers(double? squaremicrometers) + { + if (squaremicrometers.HasValue) + { + return new Area(squaremicrometers.Value*1e-12); + } + else + { + return null; + } + } + + /// + /// Get nullable Area from nullable SquareMiles. + /// + public static Area? FromSquareMiles(double? squaremiles) + { + if (squaremiles.HasValue) + { + return new Area(squaremiles.Value*2.59e6); + } + else + { + return null; + } + } + + /// + /// Get nullable Area from nullable SquareMillimeters. + /// + public static Area? FromSquareMillimeters(double? squaremillimeters) + { + if (squaremillimeters.HasValue) + { + return new Area(squaremillimeters.Value*1e-6); + } + else + { + return null; + } + } + + /// + /// Get nullable Area from nullable SquareYards. + /// + public static Area? FromSquareYards(double? squareyards) + { + if (squareyards.HasValue) + { + return new Area(squareyards.Value*0.836127); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs index 4c8181addb..1b3bd24bea 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs @@ -224,6 +224,157 @@ public static Density FromTonnesPerCubicMillimeter(double tonnespercubicmillimet } + /// + /// Get nullable Density from nullable KilogramsPerCubicCentimeter. + /// + public static Density? FromKilogramsPerCubicCentimeter(double? kilogramspercubiccentimeter) + { + if (kilogramspercubiccentimeter.HasValue) + { + return new Density(kilogramspercubiccentimeter.Value*100000000); + } + else + { + return null; + } + } + + /// + /// Get nullable Density from nullable KilogramsPerCubicMeter. + /// + public static Density? FromKilogramsPerCubicMeter(double? kilogramspercubicmeter) + { + if (kilogramspercubicmeter.HasValue) + { + return new Density(kilogramspercubicmeter.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Density from nullable KilogramsPerCubicMillimeter. + /// + public static Density? FromKilogramsPerCubicMillimeter(double? kilogramspercubicmillimeter) + { + if (kilogramspercubicmillimeter.HasValue) + { + return new Density(kilogramspercubicmillimeter.Value*1000000000000); + } + else + { + return null; + } + } + + /// + /// Get nullable Density from nullable KilopoundsPerCubicFoot. + /// + public static Density? FromKilopoundsPerCubicFoot(double? kilopoundspercubicfoot) + { + if (kilopoundspercubicfoot.HasValue) + { + return new Density((kilopoundspercubicfoot.Value/0.062427961) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Density from nullable KilopoundsPerCubicInch. + /// + public static Density? FromKilopoundsPerCubicInch(double? kilopoundspercubicinch) + { + if (kilopoundspercubicinch.HasValue) + { + return new Density((kilopoundspercubicinch.Value*27679.904710191) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Density from nullable PoundsPerCubicFoot. + /// + public static Density? FromPoundsPerCubicFoot(double? poundspercubicfoot) + { + if (poundspercubicfoot.HasValue) + { + return new Density(poundspercubicfoot.Value/0.062427961); + } + else + { + return null; + } + } + + /// + /// Get nullable Density from nullable PoundsPerCubicInch. + /// + public static Density? FromPoundsPerCubicInch(double? poundspercubicinch) + { + if (poundspercubicinch.HasValue) + { + return new Density(poundspercubicinch.Value*27679.904710191); + } + else + { + return null; + } + } + + /// + /// Get nullable Density from nullable TonnesPerCubicCentimeter. + /// + public static Density? FromTonnesPerCubicCentimeter(double? tonnespercubiccentimeter) + { + if (tonnespercubiccentimeter.HasValue) + { + return new Density(tonnespercubiccentimeter.Value*100000000000); + } + else + { + return null; + } + } + + /// + /// Get nullable Density from nullable TonnesPerCubicMeter. + /// + public static Density? FromTonnesPerCubicMeter(double? tonnespercubicmeter) + { + if (tonnespercubicmeter.HasValue) + { + return new Density(tonnespercubicmeter.Value*1000); + } + else + { + return null; + } + } + + /// + /// Get nullable Density from nullable TonnesPerCubicMillimeter. + /// + public static Density? FromTonnesPerCubicMillimeter(double? tonnespercubicmillimeter) + { + if (tonnespercubicmillimeter.HasValue) + { + return new Density(tonnespercubicmillimeter.Value*1000000000000000); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs index 12edc70311..ba8c12f712 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs @@ -224,6 +224,157 @@ public static Duration FromYears(double years) } + /// + /// Get nullable Duration from nullable Days. + /// + public static Duration? FromDays(double? days) + { + if (days.HasValue) + { + return new Duration(days.Value*24*3600); + } + else + { + return null; + } + } + + /// + /// Get nullable Duration from nullable Hours. + /// + public static Duration? FromHours(double? hours) + { + if (hours.HasValue) + { + return new Duration(hours.Value*3600); + } + else + { + return null; + } + } + + /// + /// Get nullable Duration from nullable Microseconds. + /// + public static Duration? FromMicroseconds(double? microseconds) + { + if (microseconds.HasValue) + { + return new Duration(microseconds.Value/1e6); + } + else + { + return null; + } + } + + /// + /// Get nullable Duration from nullable Milliseconds. + /// + public static Duration? FromMilliseconds(double? milliseconds) + { + if (milliseconds.HasValue) + { + return new Duration(milliseconds.Value/1e3); + } + else + { + return null; + } + } + + /// + /// Get nullable Duration from nullable Minutes. + /// + public static Duration? FromMinutes(double? minutes) + { + if (minutes.HasValue) + { + return new Duration(minutes.Value*60); + } + else + { + return null; + } + } + + /// + /// Get nullable Duration from nullable Months. + /// + public static Duration? FromMonths(double? months) + { + if (months.HasValue) + { + return new Duration(months.Value*30*24*3600); + } + else + { + return null; + } + } + + /// + /// Get nullable Duration from nullable Nanoseconds. + /// + public static Duration? FromNanoseconds(double? nanoseconds) + { + if (nanoseconds.HasValue) + { + return new Duration(nanoseconds.Value/1e9); + } + else + { + return null; + } + } + + /// + /// Get nullable Duration from nullable Seconds. + /// + public static Duration? FromSeconds(double? seconds) + { + if (seconds.HasValue) + { + return new Duration(seconds.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Duration from nullable Weeks. + /// + public static Duration? FromWeeks(double? weeks) + { + if (weeks.HasValue) + { + return new Duration(weeks.Value*7*24*3600); + } + else + { + return null; + } + } + + /// + /// Get nullable Duration from nullable Years. + /// + public static Duration? FromYears(double? years) + { + if (years.HasValue) + { + return new Duration(years.Value*365*24*3600); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs index c0fa48fdea..d1e4cfecf5 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs @@ -160,6 +160,97 @@ public static ElectricCurrent FromNanoamperes(double nanoamperes) } + /// + /// Get nullable ElectricCurrent from nullable Amperes. + /// + public static ElectricCurrent? FromAmperes(double? amperes) + { + if (amperes.HasValue) + { + return new ElectricCurrent(amperes.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable ElectricCurrent from nullable Kiloamperes. + /// + public static ElectricCurrent? FromKiloamperes(double? kiloamperes) + { + if (kiloamperes.HasValue) + { + return new ElectricCurrent((kiloamperes.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable ElectricCurrent from nullable Megaamperes. + /// + public static ElectricCurrent? FromMegaamperes(double? megaamperes) + { + if (megaamperes.HasValue) + { + return new ElectricCurrent((megaamperes.Value) * 1e6d); + } + else + { + return null; + } + } + + /// + /// Get nullable ElectricCurrent from nullable Microamperes. + /// + public static ElectricCurrent? FromMicroamperes(double? microamperes) + { + if (microamperes.HasValue) + { + return new ElectricCurrent((microamperes.Value) * 1e-6d); + } + else + { + return null; + } + } + + /// + /// Get nullable ElectricCurrent from nullable Milliamperes. + /// + public static ElectricCurrent? FromMilliamperes(double? milliamperes) + { + if (milliamperes.HasValue) + { + return new ElectricCurrent((milliamperes.Value) * 1e-3d); + } + else + { + return null; + } + } + + /// + /// Get nullable ElectricCurrent from nullable Nanoamperes. + /// + public static ElectricCurrent? FromNanoamperes(double? nanoamperes) + { + if (nanoamperes.HasValue) + { + return new ElectricCurrent((nanoamperes.Value) * 1e-9d); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs index e90ee4b000..df77576fd9 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs @@ -144,6 +144,82 @@ public static ElectricPotential FromVolts(double volts) } + /// + /// Get nullable ElectricPotential from nullable Kilovolts. + /// + public static ElectricPotential? FromKilovolts(double? kilovolts) + { + if (kilovolts.HasValue) + { + return new ElectricPotential((kilovolts.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable ElectricPotential from nullable Megavolts. + /// + public static ElectricPotential? FromMegavolts(double? megavolts) + { + if (megavolts.HasValue) + { + return new ElectricPotential((megavolts.Value) * 1e6d); + } + else + { + return null; + } + } + + /// + /// Get nullable ElectricPotential from nullable Microvolts. + /// + public static ElectricPotential? FromMicrovolts(double? microvolts) + { + if (microvolts.HasValue) + { + return new ElectricPotential((microvolts.Value) * 1e-6d); + } + else + { + return null; + } + } + + /// + /// Get nullable ElectricPotential from nullable Millivolts. + /// + public static ElectricPotential? FromMillivolts(double? millivolts) + { + if (millivolts.HasValue) + { + return new ElectricPotential((millivolts.Value) * 1e-3d); + } + else + { + return null; + } + } + + /// + /// Get nullable ElectricPotential from nullable Volts. + /// + public static ElectricPotential? FromVolts(double? volts) + { + if (volts.HasValue) + { + return new ElectricPotential(volts.Value); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs index 75fcdf4d2d..4f10995161 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs @@ -112,6 +112,52 @@ public static ElectricResistance FromOhms(double ohms) } + /// + /// Get nullable ElectricResistance from nullable Kiloohms. + /// + public static ElectricResistance? FromKiloohms(double? kiloohms) + { + if (kiloohms.HasValue) + { + return new ElectricResistance((kiloohms.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable ElectricResistance from nullable Megaohms. + /// + public static ElectricResistance? FromMegaohms(double? megaohms) + { + if (megaohms.HasValue) + { + return new ElectricResistance((megaohms.Value) * 1e6d); + } + else + { + return null; + } + } + + /// + /// Get nullable ElectricResistance from nullable Ohms. + /// + public static ElectricResistance? FromOhms(double? ohms) + { + if (ohms.HasValue) + { + return new ElectricResistance(ohms.Value); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs index adff0909e5..0925f391fd 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs @@ -272,6 +272,202 @@ public static Energy FromWattHours(double watthours) } + /// + /// Get nullable Energy from nullable BritishThermalUnits. + /// + public static Energy? FromBritishThermalUnits(double? britishthermalunits) + { + if (britishthermalunits.HasValue) + { + return new Energy(britishthermalunits.Value*1055.05585262); + } + else + { + return null; + } + } + + /// + /// Get nullable Energy from nullable Calories. + /// + public static Energy? FromCalories(double? calories) + { + if (calories.HasValue) + { + return new Energy(calories.Value*4.184); + } + else + { + return null; + } + } + + /// + /// Get nullable Energy from nullable ElectronVolts. + /// + public static Energy? FromElectronVolts(double? electronvolts) + { + if (electronvolts.HasValue) + { + return new Energy(electronvolts.Value*1.602176565e-19); + } + else + { + return null; + } + } + + /// + /// Get nullable Energy from nullable Ergs. + /// + public static Energy? FromErgs(double? ergs) + { + if (ergs.HasValue) + { + return new Energy(ergs.Value*1e-7); + } + else + { + return null; + } + } + + /// + /// Get nullable Energy from nullable FootPounds. + /// + public static Energy? FromFootPounds(double? footpounds) + { + if (footpounds.HasValue) + { + return new Energy(footpounds.Value*1.355817948); + } + else + { + return null; + } + } + + /// + /// Get nullable Energy from nullable GigawattHours. + /// + public static Energy? FromGigawattHours(double? gigawatthours) + { + if (gigawatthours.HasValue) + { + return new Energy((gigawatthours.Value*3600d) * 1e9d); + } + else + { + return null; + } + } + + /// + /// Get nullable Energy from nullable Joules. + /// + public static Energy? FromJoules(double? joules) + { + if (joules.HasValue) + { + return new Energy(joules.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Energy from nullable Kilocalories. + /// + public static Energy? FromKilocalories(double? kilocalories) + { + if (kilocalories.HasValue) + { + return new Energy((kilocalories.Value*4.184) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Energy from nullable Kilojoules. + /// + public static Energy? FromKilojoules(double? kilojoules) + { + if (kilojoules.HasValue) + { + return new Energy((kilojoules.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Energy from nullable KilowattHours. + /// + public static Energy? FromKilowattHours(double? kilowatthours) + { + if (kilowatthours.HasValue) + { + return new Energy((kilowatthours.Value*3600d) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Energy from nullable Megajoules. + /// + public static Energy? FromMegajoules(double? megajoules) + { + if (megajoules.HasValue) + { + return new Energy((megajoules.Value) * 1e6d); + } + else + { + return null; + } + } + + /// + /// Get nullable Energy from nullable MegawattHours. + /// + public static Energy? FromMegawattHours(double? megawatthours) + { + if (megawatthours.HasValue) + { + return new Energy((megawatthours.Value*3600d) * 1e6d); + } + else + { + return null; + } + } + + /// + /// Get nullable Energy from nullable WattHours. + /// + public static Energy? FromWattHours(double? watthours) + { + if (watthours.HasValue) + { + return new Energy(watthours.Value*3600d); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs index c174e41f5f..43dcf3cdee 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs @@ -160,6 +160,97 @@ public static Flow FromUsGallonsPerMinute(double usgallonsperminute) } + /// + /// Get nullable Flow from nullable CubicFeetPerSecond. + /// + public static Flow? FromCubicFeetPerSecond(double? cubicfeetpersecond) + { + if (cubicfeetpersecond.HasValue) + { + return new Flow(cubicfeetpersecond.Value/35.314666213); + } + else + { + return null; + } + } + + /// + /// Get nullable Flow from nullable CubicMetersPerHour. + /// + public static Flow? FromCubicMetersPerHour(double? cubicmetersperhour) + { + if (cubicmetersperhour.HasValue) + { + return new Flow(cubicmetersperhour.Value/3600); + } + else + { + return null; + } + } + + /// + /// Get nullable Flow from nullable CubicMetersPerSecond. + /// + public static Flow? FromCubicMetersPerSecond(double? cubicmeterspersecond) + { + if (cubicmeterspersecond.HasValue) + { + return new Flow(cubicmeterspersecond.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Flow from nullable LitersPerMinute. + /// + public static Flow? FromLitersPerMinute(double? litersperminute) + { + if (litersperminute.HasValue) + { + return new Flow(litersperminute.Value/60000.00000); + } + else + { + return null; + } + } + + /// + /// Get nullable Flow from nullable MillionUsGallonsPerDay. + /// + public static Flow? FromMillionUsGallonsPerDay(double? millionusgallonsperday) + { + if (millionusgallonsperday.HasValue) + { + return new Flow(millionusgallonsperday.Value/22.824465227); + } + else + { + return null; + } + } + + /// + /// Get nullable Flow from nullable UsGallonsPerMinute. + /// + public static Flow? FromUsGallonsPerMinute(double? usgallonsperminute) + { + if (usgallonsperminute.HasValue) + { + return new Flow(usgallonsperminute.Value/15850.323141489); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs index b88727b337..31906db791 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs @@ -192,6 +192,127 @@ public static Force FromTonnesForce(double tonnesforce) } + /// + /// Get nullable Force from nullable Dyne. + /// + public static Force? FromDyne(double? dyne) + { + if (dyne.HasValue) + { + return new Force(dyne.Value/1e5); + } + else + { + return null; + } + } + + /// + /// Get nullable Force from nullable KilogramsForce. + /// + public static Force? FromKilogramsForce(double? kilogramsforce) + { + if (kilogramsforce.HasValue) + { + return new Force(kilogramsforce.Value*Constants.Gravity); + } + else + { + return null; + } + } + + /// + /// Get nullable Force from nullable Kilonewtons. + /// + public static Force? FromKilonewtons(double? kilonewtons) + { + if (kilonewtons.HasValue) + { + return new Force((kilonewtons.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Force from nullable KiloPonds. + /// + public static Force? FromKiloPonds(double? kiloponds) + { + if (kiloponds.HasValue) + { + return new Force(kiloponds.Value*Constants.Gravity); + } + else + { + return null; + } + } + + /// + /// Get nullable Force from nullable Newtons. + /// + public static Force? FromNewtons(double? newtons) + { + if (newtons.HasValue) + { + return new Force(newtons.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Force from nullable Poundals. + /// + public static Force? FromPoundals(double? poundals) + { + if (poundals.HasValue) + { + return new Force(poundals.Value*0.13825502798973041652092282466083); + } + else + { + return null; + } + } + + /// + /// Get nullable Force from nullable PoundsForce. + /// + public static Force? FromPoundsForce(double? poundsforce) + { + if (poundsforce.HasValue) + { + return new Force(poundsforce.Value*4.4482216152605095551842641431421); + } + else + { + return null; + } + } + + /// + /// Get nullable Force from nullable TonnesForce. + /// + public static Force? FromTonnesForce(double? tonnesforce) + { + if (tonnesforce.HasValue) + { + return new Force(tonnesforce.Value*Constants.Gravity*1000); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs index 3fec0d7ad0..a2c202822e 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs @@ -80,6 +80,22 @@ public static ForceChangeRate FromNewtonsPerSecond(double newtonspersecond) } + /// + /// Get nullable ForceChangeRate from nullable NewtonsPerSecond. + /// + public static ForceChangeRate? FromNewtonsPerSecond(double? newtonspersecond) + { + if (newtonspersecond.HasValue) + { + return new ForceChangeRate(newtonspersecond.Value); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs index b15c2e4552..76b507d3b4 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs @@ -192,6 +192,127 @@ public static Frequency FromTerahertz(double terahertz) } + /// + /// Get nullable Frequency from nullable CyclesPerHour. + /// + public static Frequency? FromCyclesPerHour(double? cyclesperhour) + { + if (cyclesperhour.HasValue) + { + return new Frequency(cyclesperhour.Value*3600); + } + else + { + return null; + } + } + + /// + /// Get nullable Frequency from nullable CyclesPerMinute. + /// + public static Frequency? FromCyclesPerMinute(double? cyclesperminute) + { + if (cyclesperminute.HasValue) + { + return new Frequency(cyclesperminute.Value*60); + } + else + { + return null; + } + } + + /// + /// Get nullable Frequency from nullable Gigahertz. + /// + public static Frequency? FromGigahertz(double? gigahertz) + { + if (gigahertz.HasValue) + { + return new Frequency((gigahertz.Value) * 1e9d); + } + else + { + return null; + } + } + + /// + /// Get nullable Frequency from nullable Hertz. + /// + public static Frequency? FromHertz(double? hertz) + { + if (hertz.HasValue) + { + return new Frequency(hertz.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Frequency from nullable Kilohertz. + /// + public static Frequency? FromKilohertz(double? kilohertz) + { + if (kilohertz.HasValue) + { + return new Frequency((kilohertz.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Frequency from nullable Megahertz. + /// + public static Frequency? FromMegahertz(double? megahertz) + { + if (megahertz.HasValue) + { + return new Frequency((megahertz.Value) * 1e6d); + } + else + { + return null; + } + } + + /// + /// Get nullable Frequency from nullable RadiansPerSecond. + /// + public static Frequency? FromRadiansPerSecond(double? radianspersecond) + { + if (radianspersecond.HasValue) + { + return new Frequency(radianspersecond.Value/6.2831853072); + } + else + { + return null; + } + } + + /// + /// Get nullable Frequency from nullable Terahertz. + /// + public static Frequency? FromTerahertz(double? terahertz) + { + if (terahertz.HasValue) + { + return new Frequency((terahertz.Value) * 1e12d); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs index 2db1dc55cc..0c418c6f87 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs @@ -480,6 +480,397 @@ public static Information FromTerabytes(double terabytes) } + /// + /// Get nullable Information from nullable Bits. + /// + public static Information? FromBits(double? bits) + { + if (bits.HasValue) + { + return new Information(Convert.ToDecimal(bits.Value)); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Bytes. + /// + public static Information? FromBytes(double? bytes) + { + if (bytes.HasValue) + { + return new Information(Convert.ToDecimal(bytes.Value*8d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Exabits. + /// + public static Information? FromExabits(double? exabits) + { + if (exabits.HasValue) + { + return new Information(Convert.ToDecimal((exabits.Value) * 1e18d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Exabytes. + /// + public static Information? FromExabytes(double? exabytes) + { + if (exabytes.HasValue) + { + return new Information(Convert.ToDecimal((exabytes.Value*8d) * 1e18d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Exbibits. + /// + public static Information? FromExbibits(double? exbibits) + { + if (exbibits.HasValue) + { + return new Information(Convert.ToDecimal((exbibits.Value) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024))); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Exbibytes. + /// + public static Information? FromExbibytes(double? exbibytes) + { + if (exbibytes.HasValue) + { + return new Information(Convert.ToDecimal((exbibytes.Value*8d) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024))); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Gibibits. + /// + public static Information? FromGibibits(double? gibibits) + { + if (gibibits.HasValue) + { + return new Information(Convert.ToDecimal((gibibits.Value) * (1024d * 1024 * 1024))); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Gibibytes. + /// + public static Information? FromGibibytes(double? gibibytes) + { + if (gibibytes.HasValue) + { + return new Information(Convert.ToDecimal((gibibytes.Value*8d) * (1024d * 1024 * 1024))); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Gigabits. + /// + public static Information? FromGigabits(double? gigabits) + { + if (gigabits.HasValue) + { + return new Information(Convert.ToDecimal((gigabits.Value) * 1e9d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Gigabytes. + /// + public static Information? FromGigabytes(double? gigabytes) + { + if (gigabytes.HasValue) + { + return new Information(Convert.ToDecimal((gigabytes.Value*8d) * 1e9d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Kibibits. + /// + public static Information? FromKibibits(double? kibibits) + { + if (kibibits.HasValue) + { + return new Information(Convert.ToDecimal((kibibits.Value) * 1024d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Kibibytes. + /// + public static Information? FromKibibytes(double? kibibytes) + { + if (kibibytes.HasValue) + { + return new Information(Convert.ToDecimal((kibibytes.Value*8d) * 1024d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Kilobits. + /// + public static Information? FromKilobits(double? kilobits) + { + if (kilobits.HasValue) + { + return new Information(Convert.ToDecimal((kilobits.Value) * 1e3d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Kilobytes. + /// + public static Information? FromKilobytes(double? kilobytes) + { + if (kilobytes.HasValue) + { + return new Information(Convert.ToDecimal((kilobytes.Value*8d) * 1e3d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Mebibits. + /// + public static Information? FromMebibits(double? mebibits) + { + if (mebibits.HasValue) + { + return new Information(Convert.ToDecimal((mebibits.Value) * (1024d * 1024))); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Mebibytes. + /// + public static Information? FromMebibytes(double? mebibytes) + { + if (mebibytes.HasValue) + { + return new Information(Convert.ToDecimal((mebibytes.Value*8d) * (1024d * 1024))); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Megabits. + /// + public static Information? FromMegabits(double? megabits) + { + if (megabits.HasValue) + { + return new Information(Convert.ToDecimal((megabits.Value) * 1e6d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Megabytes. + /// + public static Information? FromMegabytes(double? megabytes) + { + if (megabytes.HasValue) + { + return new Information(Convert.ToDecimal((megabytes.Value*8d) * 1e6d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Pebibits. + /// + public static Information? FromPebibits(double? pebibits) + { + if (pebibits.HasValue) + { + return new Information(Convert.ToDecimal((pebibits.Value) * (1024d * 1024 * 1024 * 1024 * 1024))); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Pebibytes. + /// + public static Information? FromPebibytes(double? pebibytes) + { + if (pebibytes.HasValue) + { + return new Information(Convert.ToDecimal((pebibytes.Value*8d) * (1024d * 1024 * 1024 * 1024 * 1024))); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Petabits. + /// + public static Information? FromPetabits(double? petabits) + { + if (petabits.HasValue) + { + return new Information(Convert.ToDecimal((petabits.Value) * 1e15d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Petabytes. + /// + public static Information? FromPetabytes(double? petabytes) + { + if (petabytes.HasValue) + { + return new Information(Convert.ToDecimal((petabytes.Value*8d) * 1e15d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Tebibits. + /// + public static Information? FromTebibits(double? tebibits) + { + if (tebibits.HasValue) + { + return new Information(Convert.ToDecimal((tebibits.Value) * (1024d * 1024 * 1024 * 1024))); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Tebibytes. + /// + public static Information? FromTebibytes(double? tebibytes) + { + if (tebibytes.HasValue) + { + return new Information(Convert.ToDecimal((tebibytes.Value*8d) * (1024d * 1024 * 1024 * 1024))); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Terabits. + /// + public static Information? FromTerabits(double? terabits) + { + if (terabits.HasValue) + { + return new Information(Convert.ToDecimal((terabits.Value) * 1e12d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Information from nullable Terabytes. + /// + public static Information? FromTerabytes(double? terabytes) + { + if (terabytes.HasValue) + { + return new Information(Convert.ToDecimal((terabytes.Value*8d) * 1e12d)); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs b/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs index 1cbb6a254b..2b669ca2e5 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs @@ -192,6 +192,127 @@ public static KinematicViscosity FromStokes(double stokes) } + /// + /// Get nullable KinematicViscosity from nullable Centistokes. + /// + public static KinematicViscosity? FromCentistokes(double? centistokes) + { + if (centistokes.HasValue) + { + return new KinematicViscosity((centistokes.Value/1e4) * 1e-2d); + } + else + { + return null; + } + } + + /// + /// Get nullable KinematicViscosity from nullable Decistokes. + /// + public static KinematicViscosity? FromDecistokes(double? decistokes) + { + if (decistokes.HasValue) + { + return new KinematicViscosity((decistokes.Value/1e4) * 1e-1d); + } + else + { + return null; + } + } + + /// + /// Get nullable KinematicViscosity from nullable Kilostokes. + /// + public static KinematicViscosity? FromKilostokes(double? kilostokes) + { + if (kilostokes.HasValue) + { + return new KinematicViscosity((kilostokes.Value/1e4) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable KinematicViscosity from nullable Microstokes. + /// + public static KinematicViscosity? FromMicrostokes(double? microstokes) + { + if (microstokes.HasValue) + { + return new KinematicViscosity((microstokes.Value/1e4) * 1e-6d); + } + else + { + return null; + } + } + + /// + /// Get nullable KinematicViscosity from nullable Millistokes. + /// + public static KinematicViscosity? FromMillistokes(double? millistokes) + { + if (millistokes.HasValue) + { + return new KinematicViscosity((millistokes.Value/1e4) * 1e-3d); + } + else + { + return null; + } + } + + /// + /// Get nullable KinematicViscosity from nullable Nanostokes. + /// + public static KinematicViscosity? FromNanostokes(double? nanostokes) + { + if (nanostokes.HasValue) + { + return new KinematicViscosity((nanostokes.Value/1e4) * 1e-9d); + } + else + { + return null; + } + } + + /// + /// Get nullable KinematicViscosity from nullable SquareMetersPerSecond. + /// + public static KinematicViscosity? FromSquareMetersPerSecond(double? squaremeterspersecond) + { + if (squaremeterspersecond.HasValue) + { + return new KinematicViscosity(squaremeterspersecond.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable KinematicViscosity from nullable Stokes. + /// + public static KinematicViscosity? FromStokes(double? stokes) + { + if (stokes.HasValue) + { + return new KinematicViscosity(stokes.Value/1e4); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs index ce4bc8855a..b4e247760c 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs @@ -288,6 +288,217 @@ public static Length FromYards(double yards) } + /// + /// Get nullable Length from nullable Centimeters. + /// + public static Length? FromCentimeters(double? centimeters) + { + if (centimeters.HasValue) + { + return new Length((centimeters.Value) * 1e-2d); + } + else + { + return null; + } + } + + /// + /// Get nullable Length from nullable Decimeters. + /// + public static Length? FromDecimeters(double? decimeters) + { + if (decimeters.HasValue) + { + return new Length((decimeters.Value) * 1e-1d); + } + else + { + return null; + } + } + + /// + /// Get nullable Length from nullable Feet. + /// + public static Length? FromFeet(double? feet) + { + if (feet.HasValue) + { + return new Length(feet.Value*0.3048); + } + else + { + return null; + } + } + + /// + /// Get nullable Length from nullable Inches. + /// + public static Length? FromInches(double? inches) + { + if (inches.HasValue) + { + return new Length(inches.Value*2.54e-2); + } + else + { + return null; + } + } + + /// + /// Get nullable Length from nullable Kilometers. + /// + public static Length? FromKilometers(double? kilometers) + { + if (kilometers.HasValue) + { + return new Length((kilometers.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Length from nullable Meters. + /// + public static Length? FromMeters(double? meters) + { + if (meters.HasValue) + { + return new Length(meters.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Length from nullable Microinches. + /// + public static Length? FromMicroinches(double? microinches) + { + if (microinches.HasValue) + { + return new Length(microinches.Value*2.54e-8); + } + else + { + return null; + } + } + + /// + /// Get nullable Length from nullable Micrometers. + /// + public static Length? FromMicrometers(double? micrometers) + { + if (micrometers.HasValue) + { + return new Length((micrometers.Value) * 1e-6d); + } + else + { + return null; + } + } + + /// + /// Get nullable Length from nullable Mils. + /// + public static Length? FromMils(double? mils) + { + if (mils.HasValue) + { + return new Length(mils.Value*2.54e-5); + } + else + { + return null; + } + } + + /// + /// Get nullable Length from nullable Miles. + /// + public static Length? FromMiles(double? miles) + { + if (miles.HasValue) + { + return new Length(miles.Value*1609.34); + } + else + { + return null; + } + } + + /// + /// Get nullable Length from nullable Millimeters. + /// + public static Length? FromMillimeters(double? millimeters) + { + if (millimeters.HasValue) + { + return new Length((millimeters.Value) * 1e-3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Length from nullable Nanometers. + /// + public static Length? FromNanometers(double? nanometers) + { + if (nanometers.HasValue) + { + return new Length((nanometers.Value) * 1e-9d); + } + else + { + return null; + } + } + + /// + /// Get nullable Length from nullable NauticalMiles. + /// + public static Length? FromNauticalMiles(double? nauticalmiles) + { + if (nauticalmiles.HasValue) + { + return new Length(nauticalmiles.Value*1852); + } + else + { + return null; + } + } + + /// + /// Get nullable Length from nullable Yards. + /// + public static Length? FromYards(double? yards) + { + if (yards.HasValue) + { + return new Length(yards.Value*0.9144); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs index 885f091286..cc1deb4fd0 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs @@ -96,6 +96,37 @@ public static Level FromNepers(double nepers) } + /// + /// Get nullable Level from nullable Decibels. + /// + public static Level? FromDecibels(double? decibels) + { + if (decibels.HasValue) + { + return new Level(decibels.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Level from nullable Nepers. + /// + public static Level? FromNepers(double? nepers) + { + if (nepers.HasValue) + { + return new Level((1/0.115129254)*nepers.Value); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs index e97964b3b8..16faf9931c 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs @@ -336,6 +336,262 @@ public static Mass FromTonnes(double tonnes) } + /// + /// Get nullable Mass from nullable Centigrams. + /// + public static Mass? FromCentigrams(double? centigrams) + { + if (centigrams.HasValue) + { + return new Mass((centigrams.Value/1e3) * 1e-2d); + } + else + { + return null; + } + } + + /// + /// Get nullable Mass from nullable Decagrams. + /// + public static Mass? FromDecagrams(double? decagrams) + { + if (decagrams.HasValue) + { + return new Mass((decagrams.Value/1e3) * 1e1d); + } + else + { + return null; + } + } + + /// + /// Get nullable Mass from nullable Decigrams. + /// + public static Mass? FromDecigrams(double? decigrams) + { + if (decigrams.HasValue) + { + return new Mass((decigrams.Value/1e3) * 1e-1d); + } + else + { + return null; + } + } + + /// + /// Get nullable Mass from nullable Grams. + /// + public static Mass? FromGrams(double? grams) + { + if (grams.HasValue) + { + return new Mass(grams.Value/1e3); + } + else + { + return null; + } + } + + /// + /// Get nullable Mass from nullable Hectograms. + /// + public static Mass? FromHectograms(double? hectograms) + { + if (hectograms.HasValue) + { + return new Mass((hectograms.Value/1e3) * 1e2d); + } + else + { + return null; + } + } + + /// + /// Get nullable Mass from nullable Kilograms. + /// + public static Mass? FromKilograms(double? kilograms) + { + if (kilograms.HasValue) + { + return new Mass((kilograms.Value/1e3) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Mass from nullable Kilotonnes. + /// + public static Mass? FromKilotonnes(double? kilotonnes) + { + if (kilotonnes.HasValue) + { + return new Mass((kilotonnes.Value*1e3) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Mass from nullable LongTons. + /// + public static Mass? FromLongTons(double? longtons) + { + if (longtons.HasValue) + { + return new Mass(longtons.Value*1016.0469088); + } + else + { + return null; + } + } + + /// + /// Get nullable Mass from nullable Megatonnes. + /// + public static Mass? FromMegatonnes(double? megatonnes) + { + if (megatonnes.HasValue) + { + return new Mass((megatonnes.Value*1e3) * 1e6d); + } + else + { + return null; + } + } + + /// + /// Get nullable Mass from nullable Micrograms. + /// + public static Mass? FromMicrograms(double? micrograms) + { + if (micrograms.HasValue) + { + return new Mass((micrograms.Value/1e3) * 1e-6d); + } + else + { + return null; + } + } + + /// + /// Get nullable Mass from nullable Milligrams. + /// + public static Mass? FromMilligrams(double? milligrams) + { + if (milligrams.HasValue) + { + return new Mass((milligrams.Value/1e3) * 1e-3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Mass from nullable Nanograms. + /// + public static Mass? FromNanograms(double? nanograms) + { + if (nanograms.HasValue) + { + return new Mass((nanograms.Value/1e3) * 1e-9d); + } + else + { + return null; + } + } + + /// + /// Get nullable Mass from nullable Ounces. + /// + public static Mass? FromOunces(double? ounces) + { + if (ounces.HasValue) + { + return new Mass(ounces.Value/35.2739619); + } + else + { + return null; + } + } + + /// + /// Get nullable Mass from nullable Pounds. + /// + public static Mass? FromPounds(double? pounds) + { + if (pounds.HasValue) + { + return new Mass(pounds.Value*0.45359237); + } + else + { + return null; + } + } + + /// + /// Get nullable Mass from nullable ShortTons. + /// + public static Mass? FromShortTons(double? shorttons) + { + if (shorttons.HasValue) + { + return new Mass(shorttons.Value*907.18474); + } + else + { + return null; + } + } + + /// + /// Get nullable Mass from nullable Stone. + /// + public static Mass? FromStone(double? stone) + { + if (stone.HasValue) + { + return new Mass(stone.Value/0.1574731728702698); + } + else + { + return null; + } + } + + /// + /// Get nullable Mass from nullable Tonnes. + /// + public static Mass? FromTonnes(double? tonnes) + { + if (tonnes.HasValue) + { + return new Mass(tonnes.Value*1e3); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs index 56fbc5a073..7b1bd733b9 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs @@ -224,6 +224,157 @@ public static MassFlow FromTonnesPerDay(double tonnesperday) } + /// + /// Get nullable MassFlow from nullable CentigramsPerSecond. + /// + public static MassFlow? FromCentigramsPerSecond(double? centigramspersecond) + { + if (centigramspersecond.HasValue) + { + return new MassFlow((centigramspersecond.Value) * 1e-2d); + } + else + { + return null; + } + } + + /// + /// Get nullable MassFlow from nullable DecagramsPerSecond. + /// + public static MassFlow? FromDecagramsPerSecond(double? decagramspersecond) + { + if (decagramspersecond.HasValue) + { + return new MassFlow((decagramspersecond.Value) * 1e1d); + } + else + { + return null; + } + } + + /// + /// Get nullable MassFlow from nullable DecigramsPerSecond. + /// + public static MassFlow? FromDecigramsPerSecond(double? decigramspersecond) + { + if (decigramspersecond.HasValue) + { + return new MassFlow((decigramspersecond.Value) * 1e-1d); + } + else + { + return null; + } + } + + /// + /// Get nullable MassFlow from nullable GramsPerSecond. + /// + public static MassFlow? FromGramsPerSecond(double? gramspersecond) + { + if (gramspersecond.HasValue) + { + return new MassFlow(gramspersecond.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MassFlow from nullable HectogramsPerSecond. + /// + public static MassFlow? FromHectogramsPerSecond(double? hectogramspersecond) + { + if (hectogramspersecond.HasValue) + { + return new MassFlow((hectogramspersecond.Value) * 1e2d); + } + else + { + return null; + } + } + + /// + /// Get nullable MassFlow from nullable KilogramsPerSecond. + /// + public static MassFlow? FromKilogramsPerSecond(double? kilogramspersecond) + { + if (kilogramspersecond.HasValue) + { + return new MassFlow((kilogramspersecond.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable MassFlow from nullable MicrogramsPerSecond. + /// + public static MassFlow? FromMicrogramsPerSecond(double? microgramspersecond) + { + if (microgramspersecond.HasValue) + { + return new MassFlow((microgramspersecond.Value) * 1e-6d); + } + else + { + return null; + } + } + + /// + /// Get nullable MassFlow from nullable MilligramsPerSecond. + /// + public static MassFlow? FromMilligramsPerSecond(double? milligramspersecond) + { + if (milligramspersecond.HasValue) + { + return new MassFlow((milligramspersecond.Value) * 1e-3d); + } + else + { + return null; + } + } + + /// + /// Get nullable MassFlow from nullable NanogramsPerSecond. + /// + public static MassFlow? FromNanogramsPerSecond(double? nanogramspersecond) + { + if (nanogramspersecond.HasValue) + { + return new MassFlow((nanogramspersecond.Value) * 1e-9d); + } + else + { + return null; + } + } + + /// + /// Get nullable MassFlow from nullable TonnesPerDay. + /// + public static MassFlow? FromTonnesPerDay(double? tonnesperday) + { + if (tonnesperday.HasValue) + { + return new MassFlow(tonnesperday.Value/0.0864000); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs index e5e7b67ab9..b7d0495e48 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs @@ -320,6 +320,247 @@ public static Power FromWatts(double watts) } + /// + /// Get nullable Power from nullable BoilerHorsepower. + /// + public static Power? FromBoilerHorsepower(double? boilerhorsepower) + { + if (boilerhorsepower.HasValue) + { + return new Power(Convert.ToDecimal(boilerhorsepower.Value*9812.5d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Power from nullable ElectricalHorsepower. + /// + public static Power? FromElectricalHorsepower(double? electricalhorsepower) + { + if (electricalhorsepower.HasValue) + { + return new Power(Convert.ToDecimal(electricalhorsepower.Value*746d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Power from nullable Femtowatts. + /// + public static Power? FromFemtowatts(double? femtowatts) + { + if (femtowatts.HasValue) + { + return new Power(Convert.ToDecimal((femtowatts.Value) * 1e-15d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Power from nullable Gigawatts. + /// + public static Power? FromGigawatts(double? gigawatts) + { + if (gigawatts.HasValue) + { + return new Power(Convert.ToDecimal((gigawatts.Value) * 1e9d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Power from nullable HydraulicHorsepower. + /// + public static Power? FromHydraulicHorsepower(double? hydraulichorsepower) + { + if (hydraulichorsepower.HasValue) + { + return new Power(Convert.ToDecimal(hydraulichorsepower.Value*745.69988145d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Power from nullable Kilowatts. + /// + public static Power? FromKilowatts(double? kilowatts) + { + if (kilowatts.HasValue) + { + return new Power(Convert.ToDecimal((kilowatts.Value) * 1e3d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Power from nullable MechanicalHorsepower. + /// + public static Power? FromMechanicalHorsepower(double? mechanicalhorsepower) + { + if (mechanicalhorsepower.HasValue) + { + return new Power(Convert.ToDecimal(mechanicalhorsepower.Value*745.69d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Power from nullable Megawatts. + /// + public static Power? FromMegawatts(double? megawatts) + { + if (megawatts.HasValue) + { + return new Power(Convert.ToDecimal((megawatts.Value) * 1e6d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Power from nullable MetricHorsepower. + /// + public static Power? FromMetricHorsepower(double? metrichorsepower) + { + if (metrichorsepower.HasValue) + { + return new Power(Convert.ToDecimal(metrichorsepower.Value*735.49875d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Power from nullable Microwatts. + /// + public static Power? FromMicrowatts(double? microwatts) + { + if (microwatts.HasValue) + { + return new Power(Convert.ToDecimal((microwatts.Value) * 1e-6d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Power from nullable Milliwatts. + /// + public static Power? FromMilliwatts(double? milliwatts) + { + if (milliwatts.HasValue) + { + return new Power(Convert.ToDecimal((milliwatts.Value) * 1e-3d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Power from nullable Nanowatts. + /// + public static Power? FromNanowatts(double? nanowatts) + { + if (nanowatts.HasValue) + { + return new Power(Convert.ToDecimal((nanowatts.Value) * 1e-9d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Power from nullable Petawatts. + /// + public static Power? FromPetawatts(double? petawatts) + { + if (petawatts.HasValue) + { + return new Power(Convert.ToDecimal((petawatts.Value) * 1e15d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Power from nullable Picowatts. + /// + public static Power? FromPicowatts(double? picowatts) + { + if (picowatts.HasValue) + { + return new Power(Convert.ToDecimal((picowatts.Value) * 1e-12d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Power from nullable Terawatts. + /// + public static Power? FromTerawatts(double? terawatts) + { + if (terawatts.HasValue) + { + return new Power(Convert.ToDecimal((terawatts.Value) * 1e12d)); + } + else + { + return null; + } + } + + /// + /// Get nullable Power from nullable Watts. + /// + public static Power? FromWatts(double? watts) + { + if (watts.HasValue) + { + return new Power(Convert.ToDecimal(watts.Value)); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs index 0d29971640..93239028f3 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs @@ -96,6 +96,37 @@ public static PowerRatio FromDecibelWatts(double decibelwatts) } + /// + /// Get nullable PowerRatio from nullable DecibelMilliwatts. + /// + public static PowerRatio? FromDecibelMilliwatts(double? decibelmilliwatts) + { + if (decibelmilliwatts.HasValue) + { + return new PowerRatio(decibelmilliwatts.Value - 30); + } + else + { + return null; + } + } + + /// + /// Get nullable PowerRatio from nullable DecibelWatts. + /// + public static PowerRatio? FromDecibelWatts(double? decibelwatts) + { + if (decibelwatts.HasValue) + { + return new PowerRatio(decibelwatts.Value); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs index 1b2f8f3cd1..fc2d63d3f0 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs @@ -592,6 +592,502 @@ public static Pressure FromTorrs(double torrs) } + /// + /// Get nullable Pressure from nullable Atmospheres. + /// + public static Pressure? FromAtmospheres(double? atmospheres) + { + if (atmospheres.HasValue) + { + return new Pressure(atmospheres.Value*1.01325*1e5); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable Bars. + /// + public static Pressure? FromBars(double? bars) + { + if (bars.HasValue) + { + return new Pressure(bars.Value*1e5); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable Centibars. + /// + public static Pressure? FromCentibars(double? centibars) + { + if (centibars.HasValue) + { + return new Pressure((centibars.Value*1e5) * 1e-2d); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable Decapascals. + /// + public static Pressure? FromDecapascals(double? decapascals) + { + if (decapascals.HasValue) + { + return new Pressure((decapascals.Value) * 1e1d); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable Decibars. + /// + public static Pressure? FromDecibars(double? decibars) + { + if (decibars.HasValue) + { + return new Pressure((decibars.Value*1e5) * 1e-1d); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable Gigapascals. + /// + public static Pressure? FromGigapascals(double? gigapascals) + { + if (gigapascals.HasValue) + { + return new Pressure((gigapascals.Value) * 1e9d); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable Hectopascals. + /// + public static Pressure? FromHectopascals(double? hectopascals) + { + if (hectopascals.HasValue) + { + return new Pressure((hectopascals.Value) * 1e2d); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable Kilobars. + /// + public static Pressure? FromKilobars(double? kilobars) + { + if (kilobars.HasValue) + { + return new Pressure((kilobars.Value*1e5) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable KilogramsForcePerSquareCentimeter. + /// + public static Pressure? FromKilogramsForcePerSquareCentimeter(double? kilogramsforcepersquarecentimeter) + { + if (kilogramsforcepersquarecentimeter.HasValue) + { + return new Pressure(kilogramsforcepersquarecentimeter.Value*9.80665*1e4); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable KilogramsForcePerSquareMeter. + /// + public static Pressure? FromKilogramsForcePerSquareMeter(double? kilogramsforcepersquaremeter) + { + if (kilogramsforcepersquaremeter.HasValue) + { + return new Pressure(kilogramsforcepersquaremeter.Value*9.80665019960652); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable KilogramsForcePerSquareMillimeter. + /// + public static Pressure? FromKilogramsForcePerSquareMillimeter(double? kilogramsforcepersquaremillimeter) + { + if (kilogramsforcepersquaremillimeter.HasValue) + { + return new Pressure(kilogramsforcepersquaremillimeter.Value*9806650.19960652); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable KilonewtonsPerSquareCentimeter. + /// + public static Pressure? FromKilonewtonsPerSquareCentimeter(double? kilonewtonspersquarecentimeter) + { + if (kilonewtonspersquarecentimeter.HasValue) + { + return new Pressure((kilonewtonspersquarecentimeter.Value*1e4) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable KilonewtonsPerSquareMeter. + /// + public static Pressure? FromKilonewtonsPerSquareMeter(double? kilonewtonspersquaremeter) + { + if (kilonewtonspersquaremeter.HasValue) + { + return new Pressure((kilonewtonspersquaremeter.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable KilonewtonsPerSquareMillimeter. + /// + public static Pressure? FromKilonewtonsPerSquareMillimeter(double? kilonewtonspersquaremillimeter) + { + if (kilonewtonspersquaremillimeter.HasValue) + { + return new Pressure((kilonewtonspersquaremillimeter.Value*1e6) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable Kilopascals. + /// + public static Pressure? FromKilopascals(double? kilopascals) + { + if (kilopascals.HasValue) + { + return new Pressure((kilopascals.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable KilopoundsForcePerSquareFoot. + /// + public static Pressure? FromKilopoundsForcePerSquareFoot(double? kilopoundsforcepersquarefoot) + { + if (kilopoundsforcepersquarefoot.HasValue) + { + return new Pressure((kilopoundsforcepersquarefoot.Value*47.8802631216372) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable KilopoundsForcePerSquareInch. + /// + public static Pressure? FromKilopoundsForcePerSquareInch(double? kilopoundsforcepersquareinch) + { + if (kilopoundsforcepersquareinch.HasValue) + { + return new Pressure((kilopoundsforcepersquareinch.Value*6894.75788951576) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable Megabars. + /// + public static Pressure? FromMegabars(double? megabars) + { + if (megabars.HasValue) + { + return new Pressure((megabars.Value*1e5) * 1e6d); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable Megapascals. + /// + public static Pressure? FromMegapascals(double? megapascals) + { + if (megapascals.HasValue) + { + return new Pressure((megapascals.Value) * 1e6d); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable Micropascals. + /// + public static Pressure? FromMicropascals(double? micropascals) + { + if (micropascals.HasValue) + { + return new Pressure((micropascals.Value) * 1e-6d); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable Millibars. + /// + public static Pressure? FromMillibars(double? millibars) + { + if (millibars.HasValue) + { + return new Pressure((millibars.Value*1e5) * 1e-3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable NewtonsPerSquareCentimeter. + /// + public static Pressure? FromNewtonsPerSquareCentimeter(double? newtonspersquarecentimeter) + { + if (newtonspersquarecentimeter.HasValue) + { + return new Pressure(newtonspersquarecentimeter.Value*1e4); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable NewtonsPerSquareMeter. + /// + public static Pressure? FromNewtonsPerSquareMeter(double? newtonspersquaremeter) + { + if (newtonspersquaremeter.HasValue) + { + return new Pressure(newtonspersquaremeter.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable NewtonsPerSquareMillimeter. + /// + public static Pressure? FromNewtonsPerSquareMillimeter(double? newtonspersquaremillimeter) + { + if (newtonspersquaremillimeter.HasValue) + { + return new Pressure(newtonspersquaremillimeter.Value*1e6); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable Pascals. + /// + public static Pressure? FromPascals(double? pascals) + { + if (pascals.HasValue) + { + return new Pressure(pascals.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable PoundsForcePerSquareFoot. + /// + public static Pressure? FromPoundsForcePerSquareFoot(double? poundsforcepersquarefoot) + { + if (poundsforcepersquarefoot.HasValue) + { + return new Pressure(poundsforcepersquarefoot.Value*47.8802631216372); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable PoundsForcePerSquareInch. + /// + public static Pressure? FromPoundsForcePerSquareInch(double? poundsforcepersquareinch) + { + if (poundsforcepersquareinch.HasValue) + { + return new Pressure(poundsforcepersquareinch.Value*6894.75788951576); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable Psi. + /// + public static Pressure? FromPsi(double? psi) + { + if (psi.HasValue) + { + return new Pressure(psi.Value*6.89464975179*1e3); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable TechnicalAtmospheres. + /// + public static Pressure? FromTechnicalAtmospheres(double? technicalatmospheres) + { + if (technicalatmospheres.HasValue) + { + return new Pressure(technicalatmospheres.Value*9.80680592331*1e4); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable TonnesForcePerSquareCentimeter. + /// + public static Pressure? FromTonnesForcePerSquareCentimeter(double? tonnesforcepersquarecentimeter) + { + if (tonnesforcepersquarecentimeter.HasValue) + { + return new Pressure(tonnesforcepersquarecentimeter.Value*98066501.9960652); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable TonnesForcePerSquareMeter. + /// + public static Pressure? FromTonnesForcePerSquareMeter(double? tonnesforcepersquaremeter) + { + if (tonnesforcepersquaremeter.HasValue) + { + return new Pressure(tonnesforcepersquaremeter.Value*9806.65019960653); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable TonnesForcePerSquareMillimeter. + /// + public static Pressure? FromTonnesForcePerSquareMillimeter(double? tonnesforcepersquaremillimeter) + { + if (tonnesforcepersquaremillimeter.HasValue) + { + return new Pressure(tonnesforcepersquaremillimeter.Value*9806650199.60653); + } + else + { + return null; + } + } + + /// + /// Get nullable Pressure from nullable Torrs. + /// + public static Pressure? FromTorrs(double? torrs) + { + if (torrs.HasValue) + { + return new Pressure(torrs.Value*1.3332266752*1e2); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs index 6bb181914f..2c23d4bc20 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs @@ -128,6 +128,67 @@ public static PressureChangeRate FromPascalsPerSecond(double pascalspersecond) } + /// + /// Get nullable PressureChangeRate from nullable AtmospheresPerSecond. + /// + public static PressureChangeRate? FromAtmospheresPerSecond(double? atmospherespersecond) + { + if (atmospherespersecond.HasValue) + { + return new PressureChangeRate(atmospherespersecond.Value * 1.01325*1e5); + } + else + { + return null; + } + } + + /// + /// Get nullable PressureChangeRate from nullable KilopascalsPerSecond. + /// + public static PressureChangeRate? FromKilopascalsPerSecond(double? kilopascalspersecond) + { + if (kilopascalspersecond.HasValue) + { + return new PressureChangeRate((kilopascalspersecond.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable PressureChangeRate from nullable MegapascalsPerSecond. + /// + public static PressureChangeRate? FromMegapascalsPerSecond(double? megapascalspersecond) + { + if (megapascalspersecond.HasValue) + { + return new PressureChangeRate((megapascalspersecond.Value) * 1e6d); + } + else + { + return null; + } + } + + /// + /// Get nullable PressureChangeRate from nullable PascalsPerSecond. + /// + public static PressureChangeRate? FromPascalsPerSecond(double? pascalspersecond) + { + if (pascalspersecond.HasValue) + { + return new PressureChangeRate(pascalspersecond.Value); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs index e4022df6e6..813fc58026 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs @@ -160,6 +160,97 @@ public static Ratio FromPercent(double percent) } + /// + /// Get nullable Ratio from nullable DecimalFractions. + /// + public static Ratio? FromDecimalFractions(double? decimalfractions) + { + if (decimalfractions.HasValue) + { + return new Ratio(decimalfractions.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Ratio from nullable PartsPerBillion. + /// + public static Ratio? FromPartsPerBillion(double? partsperbillion) + { + if (partsperbillion.HasValue) + { + return new Ratio(partsperbillion.Value/1e9); + } + else + { + return null; + } + } + + /// + /// Get nullable Ratio from nullable PartsPerMillion. + /// + public static Ratio? FromPartsPerMillion(double? partspermillion) + { + if (partspermillion.HasValue) + { + return new Ratio(partspermillion.Value/1e6); + } + else + { + return null; + } + } + + /// + /// Get nullable Ratio from nullable PartsPerThousand. + /// + public static Ratio? FromPartsPerThousand(double? partsperthousand) + { + if (partsperthousand.HasValue) + { + return new Ratio(partsperthousand.Value/1e3); + } + else + { + return null; + } + } + + /// + /// Get nullable Ratio from nullable PartsPerTrillion. + /// + public static Ratio? FromPartsPerTrillion(double? partspertrillion) + { + if (partspertrillion.HasValue) + { + return new Ratio(partspertrillion.Value/1e12); + } + else + { + return null; + } + } + + /// + /// Get nullable Ratio from nullable Percent. + /// + public static Ratio? FromPercent(double? percent) + { + if (percent.HasValue) + { + return new Ratio(percent.Value/1e2); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs index 3e054a5cb1..b4b497b459 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs @@ -192,6 +192,127 @@ public static RotationalSpeed FromRevolutionsPerSecond(double revolutionsperseco } + /// + /// Get nullable RotationalSpeed from nullable CentiradiansPerSecond. + /// + public static RotationalSpeed? FromCentiradiansPerSecond(double? centiradianspersecond) + { + if (centiradianspersecond.HasValue) + { + return new RotationalSpeed((centiradianspersecond.Value) * 1e-2d); + } + else + { + return null; + } + } + + /// + /// Get nullable RotationalSpeed from nullable DeciradiansPerSecond. + /// + public static RotationalSpeed? FromDeciradiansPerSecond(double? deciradianspersecond) + { + if (deciradianspersecond.HasValue) + { + return new RotationalSpeed((deciradianspersecond.Value) * 1e-1d); + } + else + { + return null; + } + } + + /// + /// Get nullable RotationalSpeed from nullable MicroradiansPerSecond. + /// + public static RotationalSpeed? FromMicroradiansPerSecond(double? microradianspersecond) + { + if (microradianspersecond.HasValue) + { + return new RotationalSpeed((microradianspersecond.Value) * 1e-6d); + } + else + { + return null; + } + } + + /// + /// Get nullable RotationalSpeed from nullable MilliradiansPerSecond. + /// + public static RotationalSpeed? FromMilliradiansPerSecond(double? milliradianspersecond) + { + if (milliradianspersecond.HasValue) + { + return new RotationalSpeed((milliradianspersecond.Value) * 1e-3d); + } + else + { + return null; + } + } + + /// + /// Get nullable RotationalSpeed from nullable NanoradiansPerSecond. + /// + public static RotationalSpeed? FromNanoradiansPerSecond(double? nanoradianspersecond) + { + if (nanoradianspersecond.HasValue) + { + return new RotationalSpeed((nanoradianspersecond.Value) * 1e-9d); + } + else + { + return null; + } + } + + /// + /// Get nullable RotationalSpeed from nullable RadiansPerSecond. + /// + public static RotationalSpeed? FromRadiansPerSecond(double? radianspersecond) + { + if (radianspersecond.HasValue) + { + return new RotationalSpeed(radianspersecond.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable RotationalSpeed from nullable RevolutionsPerMinute. + /// + public static RotationalSpeed? FromRevolutionsPerMinute(double? revolutionsperminute) + { + if (revolutionsperminute.HasValue) + { + return new RotationalSpeed((revolutionsperminute.Value*6.2831853072)/60); + } + else + { + return null; + } + } + + /// + /// Get nullable RotationalSpeed from nullable RevolutionsPerSecond. + /// + public static RotationalSpeed? FromRevolutionsPerSecond(double? revolutionspersecond) + { + if (revolutionspersecond.HasValue) + { + return new RotationalSpeed(revolutionspersecond.Value*6.2831853072); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs index afd83690a9..8b3dec2eb0 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs @@ -192,6 +192,127 @@ public static SpecificEnergy FromWattHoursPerKilogram(double watthoursperkilogra } + /// + /// Get nullable SpecificEnergy from nullable CaloriesPerGram. + /// + public static SpecificEnergy? FromCaloriesPerGram(double? caloriespergram) + { + if (caloriespergram.HasValue) + { + return new SpecificEnergy(caloriespergram.Value*4.184e3); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificEnergy from nullable JoulesPerKilogram. + /// + public static SpecificEnergy? FromJoulesPerKilogram(double? joulesperkilogram) + { + if (joulesperkilogram.HasValue) + { + return new SpecificEnergy(joulesperkilogram.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificEnergy from nullable KilocaloriesPerGram. + /// + public static SpecificEnergy? FromKilocaloriesPerGram(double? kilocaloriespergram) + { + if (kilocaloriespergram.HasValue) + { + return new SpecificEnergy((kilocaloriespergram.Value*4.184e3) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificEnergy from nullable KilojoulesPerKilogram. + /// + public static SpecificEnergy? FromKilojoulesPerKilogram(double? kilojoulesperkilogram) + { + if (kilojoulesperkilogram.HasValue) + { + return new SpecificEnergy((kilojoulesperkilogram.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificEnergy from nullable KilowattHoursPerKilogram. + /// + public static SpecificEnergy? FromKilowattHoursPerKilogram(double? kilowatthoursperkilogram) + { + if (kilowatthoursperkilogram.HasValue) + { + return new SpecificEnergy((kilowatthoursperkilogram.Value*3.6e3) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificEnergy from nullable MegajoulesPerKilogram. + /// + public static SpecificEnergy? FromMegajoulesPerKilogram(double? megajoulesperkilogram) + { + if (megajoulesperkilogram.HasValue) + { + return new SpecificEnergy((megajoulesperkilogram.Value) * 1e6d); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificEnergy from nullable MegawattHoursPerKilogram. + /// + public static SpecificEnergy? FromMegawattHoursPerKilogram(double? megawatthoursperkilogram) + { + if (megawatthoursperkilogram.HasValue) + { + return new SpecificEnergy((megawatthoursperkilogram.Value*3.6e3) * 1e6d); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificEnergy from nullable WattHoursPerKilogram. + /// + public static SpecificEnergy? FromWattHoursPerKilogram(double? watthoursperkilogram) + { + if (watthoursperkilogram.HasValue) + { + return new SpecificEnergy(watthoursperkilogram.Value*3.6e3); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs index f08d267818..eab4cbab8c 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs @@ -320,6 +320,247 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc } + /// + /// Get nullable SpecificWeight from nullable KilogramsForcePerCubicCentimeter. + /// + public static SpecificWeight? FromKilogramsForcePerCubicCentimeter(double? kilogramsforcepercubiccentimeter) + { + if (kilogramsforcepercubiccentimeter.HasValue) + { + return new SpecificWeight(kilogramsforcepercubiccentimeter.Value*9806650.19960652); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificWeight from nullable KilogramsForcePerCubicMeter. + /// + public static SpecificWeight? FromKilogramsForcePerCubicMeter(double? kilogramsforcepercubicmeter) + { + if (kilogramsforcepercubicmeter.HasValue) + { + return new SpecificWeight(kilogramsforcepercubicmeter.Value*9.80665019960652); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificWeight from nullable KilogramsForcePerCubicMillimeter. + /// + public static SpecificWeight? FromKilogramsForcePerCubicMillimeter(double? kilogramsforcepercubicmillimeter) + { + if (kilogramsforcepercubicmillimeter.HasValue) + { + return new SpecificWeight(kilogramsforcepercubicmillimeter.Value*9806650199.60653); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificWeight from nullable KilonewtonsPerCubicCentimeter. + /// + public static SpecificWeight? FromKilonewtonsPerCubicCentimeter(double? kilonewtonspercubiccentimeter) + { + if (kilonewtonspercubiccentimeter.HasValue) + { + return new SpecificWeight((kilonewtonspercubiccentimeter.Value*1000000) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificWeight from nullable KilonewtonsPerCubicMeter. + /// + public static SpecificWeight? FromKilonewtonsPerCubicMeter(double? kilonewtonspercubicmeter) + { + if (kilonewtonspercubicmeter.HasValue) + { + return new SpecificWeight((kilonewtonspercubicmeter.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificWeight from nullable KilonewtonsPerCubicMillimeter. + /// + public static SpecificWeight? FromKilonewtonsPerCubicMillimeter(double? kilonewtonspercubicmillimeter) + { + if (kilonewtonspercubicmillimeter.HasValue) + { + return new SpecificWeight((kilonewtonspercubicmillimeter.Value*1000000000) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificWeight from nullable KilopoundsForcePerCubicFoot. + /// + public static SpecificWeight? FromKilopoundsForcePerCubicFoot(double? kilopoundsforcepercubicfoot) + { + if (kilopoundsforcepercubicfoot.HasValue) + { + return new SpecificWeight((kilopoundsforcepercubicfoot.Value*157.087477433193) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificWeight from nullable KilopoundsForcePerCubicInch. + /// + public static SpecificWeight? FromKilopoundsForcePerCubicInch(double? kilopoundsforcepercubicinch) + { + if (kilopoundsforcepercubicinch.HasValue) + { + return new SpecificWeight((kilopoundsforcepercubicinch.Value*271447.161004558) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificWeight from nullable NewtonsPerCubicCentimeter. + /// + public static SpecificWeight? FromNewtonsPerCubicCentimeter(double? newtonspercubiccentimeter) + { + if (newtonspercubiccentimeter.HasValue) + { + return new SpecificWeight(newtonspercubiccentimeter.Value*1000000); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificWeight from nullable NewtonsPerCubicMeter. + /// + public static SpecificWeight? FromNewtonsPerCubicMeter(double? newtonspercubicmeter) + { + if (newtonspercubicmeter.HasValue) + { + return new SpecificWeight(newtonspercubicmeter.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificWeight from nullable NewtonsPerCubicMillimeter. + /// + public static SpecificWeight? FromNewtonsPerCubicMillimeter(double? newtonspercubicmillimeter) + { + if (newtonspercubicmillimeter.HasValue) + { + return new SpecificWeight(newtonspercubicmillimeter.Value*1000000000); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificWeight from nullable PoundsForcePerCubicFoot. + /// + public static SpecificWeight? FromPoundsForcePerCubicFoot(double? poundsforcepercubicfoot) + { + if (poundsforcepercubicfoot.HasValue) + { + return new SpecificWeight(poundsforcepercubicfoot.Value*157.087477433193); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificWeight from nullable PoundsForcePerCubicInch. + /// + public static SpecificWeight? FromPoundsForcePerCubicInch(double? poundsforcepercubicinch) + { + if (poundsforcepercubicinch.HasValue) + { + return new SpecificWeight(poundsforcepercubicinch.Value*271447.161004558); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificWeight from nullable TonnesForcePerCubicCentimeter. + /// + public static SpecificWeight? FromTonnesForcePerCubicCentimeter(double? tonnesforcepercubiccentimeter) + { + if (tonnesforcepercubiccentimeter.HasValue) + { + return new SpecificWeight(tonnesforcepercubiccentimeter.Value*9806650199.60653); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificWeight from nullable TonnesForcePerCubicMeter. + /// + public static SpecificWeight? FromTonnesForcePerCubicMeter(double? tonnesforcepercubicmeter) + { + if (tonnesforcepercubicmeter.HasValue) + { + return new SpecificWeight(tonnesforcepercubicmeter.Value*9806.65019960653); + } + else + { + return null; + } + } + + /// + /// Get nullable SpecificWeight from nullable TonnesForcePerCubicMillimeter. + /// + public static SpecificWeight? FromTonnesForcePerCubicMillimeter(double? tonnesforcepercubicmillimeter) + { + if (tonnesforcepercubicmillimeter.HasValue) + { + return new SpecificWeight(tonnesforcepercubicmillimeter.Value*9806650199606.53); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs index 3f4543a9f5..08de3dcff0 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs @@ -256,6 +256,187 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) } + /// + /// Get nullable Speed from nullable CentimetersPerSecond. + /// + public static Speed? FromCentimetersPerSecond(double? centimeterspersecond) + { + if (centimeterspersecond.HasValue) + { + return new Speed((centimeterspersecond.Value) * 1e-2d); + } + else + { + return null; + } + } + + /// + /// Get nullable Speed from nullable DecimetersPerSecond. + /// + public static Speed? FromDecimetersPerSecond(double? decimeterspersecond) + { + if (decimeterspersecond.HasValue) + { + return new Speed((decimeterspersecond.Value) * 1e-1d); + } + else + { + return null; + } + } + + /// + /// Get nullable Speed from nullable FeetPerSecond. + /// + public static Speed? FromFeetPerSecond(double? feetpersecond) + { + if (feetpersecond.HasValue) + { + return new Speed(feetpersecond.Value*0.3048); + } + else + { + return null; + } + } + + /// + /// Get nullable Speed from nullable KilometersPerHour. + /// + public static Speed? FromKilometersPerHour(double? kilometersperhour) + { + if (kilometersperhour.HasValue) + { + return new Speed(kilometersperhour.Value/3.6); + } + else + { + return null; + } + } + + /// + /// Get nullable Speed from nullable KilometersPerSecond. + /// + public static Speed? FromKilometersPerSecond(double? kilometerspersecond) + { + if (kilometerspersecond.HasValue) + { + return new Speed((kilometerspersecond.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Speed from nullable Knots. + /// + public static Speed? FromKnots(double? knots) + { + if (knots.HasValue) + { + return new Speed(knots.Value*0.514444); + } + else + { + return null; + } + } + + /// + /// Get nullable Speed from nullable MetersPerHour. + /// + public static Speed? FromMetersPerHour(double? metersperhour) + { + if (metersperhour.HasValue) + { + return new Speed(metersperhour.Value/3600); + } + else + { + return null; + } + } + + /// + /// Get nullable Speed from nullable MetersPerSecond. + /// + public static Speed? FromMetersPerSecond(double? meterspersecond) + { + if (meterspersecond.HasValue) + { + return new Speed(meterspersecond.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Speed from nullable MicrometersPerSecond. + /// + public static Speed? FromMicrometersPerSecond(double? micrometerspersecond) + { + if (micrometerspersecond.HasValue) + { + return new Speed((micrometerspersecond.Value) * 1e-6d); + } + else + { + return null; + } + } + + /// + /// Get nullable Speed from nullable MilesPerHour. + /// + public static Speed? FromMilesPerHour(double? milesperhour) + { + if (milesperhour.HasValue) + { + return new Speed(milesperhour.Value*0.44704); + } + else + { + return null; + } + } + + /// + /// Get nullable Speed from nullable MillimetersPerSecond. + /// + public static Speed? FromMillimetersPerSecond(double? millimeterspersecond) + { + if (millimeterspersecond.HasValue) + { + return new Speed((millimeterspersecond.Value) * 1e-3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Speed from nullable NanometersPerSecond. + /// + public static Speed? FromNanometersPerSecond(double? nanometerspersecond) + { + if (nanometerspersecond.HasValue) + { + return new Speed((nanometerspersecond.Value) * 1e-9d); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs index 0be2dc313b..f9b49346a9 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs @@ -192,6 +192,127 @@ public static Temperature FromKelvins(double kelvins) } + /// + /// Get nullable Temperature from nullable DegreesCelsius. + /// + public static Temperature? FromDegreesCelsius(double? degreescelsius) + { + if (degreescelsius.HasValue) + { + return new Temperature(degreescelsius.Value + 273.15); + } + else + { + return null; + } + } + + /// + /// Get nullable Temperature from nullable DegreesDelisle. + /// + public static Temperature? FromDegreesDelisle(double? degreesdelisle) + { + if (degreesdelisle.HasValue) + { + return new Temperature(degreesdelisle.Value*-2/3 + 373.15); + } + else + { + return null; + } + } + + /// + /// Get nullable Temperature from nullable DegreesFahrenheit. + /// + public static Temperature? FromDegreesFahrenheit(double? degreesfahrenheit) + { + if (degreesfahrenheit.HasValue) + { + return new Temperature(degreesfahrenheit.Value*5/9 + 459.67*5/9); + } + else + { + return null; + } + } + + /// + /// Get nullable Temperature from nullable DegreesNewton. + /// + public static Temperature? FromDegreesNewton(double? degreesnewton) + { + if (degreesnewton.HasValue) + { + return new Temperature(degreesnewton.Value*100/33 + 273.15); + } + else + { + return null; + } + } + + /// + /// Get nullable Temperature from nullable DegreesRankine. + /// + public static Temperature? FromDegreesRankine(double? degreesrankine) + { + if (degreesrankine.HasValue) + { + return new Temperature(degreesrankine.Value*5/9); + } + else + { + return null; + } + } + + /// + /// Get nullable Temperature from nullable DegreesReaumur. + /// + public static Temperature? FromDegreesReaumur(double? degreesreaumur) + { + if (degreesreaumur.HasValue) + { + return new Temperature(degreesreaumur.Value*5/4 + 273.15); + } + else + { + return null; + } + } + + /// + /// Get nullable Temperature from nullable DegreesRoemer. + /// + public static Temperature? FromDegreesRoemer(double? degreesroemer) + { + if (degreesroemer.HasValue) + { + return new Temperature(degreesroemer.Value*40/21 + 273.15 - 7.5*40d/21); + } + else + { + return null; + } + } + + /// + /// Get nullable Temperature from nullable Kelvins. + /// + public static Temperature? FromKelvins(double? kelvins) + { + if (kelvins.HasValue) + { + return new Temperature(kelvins.Value); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs index f1f255075d..5e8a4bb71f 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs @@ -208,6 +208,142 @@ public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double nanod } + /// + /// Get nullable TemperatureChangeRate from nullable CentidegreesCelsiusPerSecond. + /// + public static TemperatureChangeRate? FromCentidegreesCelsiusPerSecond(double? centidegreescelsiuspersecond) + { + if (centidegreescelsiuspersecond.HasValue) + { + return new TemperatureChangeRate((centidegreescelsiuspersecond.Value) * 1e-2d); + } + else + { + return null; + } + } + + /// + /// Get nullable TemperatureChangeRate from nullable DecadegreesCelsiusPerSecond. + /// + public static TemperatureChangeRate? FromDecadegreesCelsiusPerSecond(double? decadegreescelsiuspersecond) + { + if (decadegreescelsiuspersecond.HasValue) + { + return new TemperatureChangeRate((decadegreescelsiuspersecond.Value) * 1e1d); + } + else + { + return null; + } + } + + /// + /// Get nullable TemperatureChangeRate from nullable DecidegreesCelsiusPerSecond. + /// + public static TemperatureChangeRate? FromDecidegreesCelsiusPerSecond(double? decidegreescelsiuspersecond) + { + if (decidegreescelsiuspersecond.HasValue) + { + return new TemperatureChangeRate((decidegreescelsiuspersecond.Value) * 1e-1d); + } + else + { + return null; + } + } + + /// + /// Get nullable TemperatureChangeRate from nullable DegreesCelsiusPerSecond. + /// + public static TemperatureChangeRate? FromDegreesCelsiusPerSecond(double? degreescelsiuspersecond) + { + if (degreescelsiuspersecond.HasValue) + { + return new TemperatureChangeRate(degreescelsiuspersecond.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable TemperatureChangeRate from nullable HectodegreesCelsiusPerSecond. + /// + public static TemperatureChangeRate? FromHectodegreesCelsiusPerSecond(double? hectodegreescelsiuspersecond) + { + if (hectodegreescelsiuspersecond.HasValue) + { + return new TemperatureChangeRate((hectodegreescelsiuspersecond.Value) * 1e2d); + } + else + { + return null; + } + } + + /// + /// Get nullable TemperatureChangeRate from nullable KilodegreesCelsiusPerSecond. + /// + public static TemperatureChangeRate? FromKilodegreesCelsiusPerSecond(double? kilodegreescelsiuspersecond) + { + if (kilodegreescelsiuspersecond.HasValue) + { + return new TemperatureChangeRate((kilodegreescelsiuspersecond.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable TemperatureChangeRate from nullable MicrodegreesCelsiusPerSecond. + /// + public static TemperatureChangeRate? FromMicrodegreesCelsiusPerSecond(double? microdegreescelsiuspersecond) + { + if (microdegreescelsiuspersecond.HasValue) + { + return new TemperatureChangeRate((microdegreescelsiuspersecond.Value) * 1e-6d); + } + else + { + return null; + } + } + + /// + /// Get nullable TemperatureChangeRate from nullable MillidegreesCelsiusPerSecond. + /// + public static TemperatureChangeRate? FromMillidegreesCelsiusPerSecond(double? millidegreescelsiuspersecond) + { + if (millidegreescelsiuspersecond.HasValue) + { + return new TemperatureChangeRate((millidegreescelsiuspersecond.Value) * 1e-3d); + } + else + { + return null; + } + } + + /// + /// Get nullable TemperatureChangeRate from nullable NanodegreesCelsiusPerSecond. + /// + public static TemperatureChangeRate? FromNanodegreesCelsiusPerSecond(double? nanodegreescelsiuspersecond) + { + if (nanodegreescelsiuspersecond.HasValue) + { + return new TemperatureChangeRate((nanodegreescelsiuspersecond.Value) * 1e-9d); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs index 015bff6d90..954b77ef13 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs @@ -320,6 +320,247 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) } + /// + /// Get nullable Torque from nullable KilogramForceCentimeters. + /// + public static Torque? FromKilogramForceCentimeters(double? kilogramforcecentimeters) + { + if (kilogramforcecentimeters.HasValue) + { + return new Torque(kilogramforcecentimeters.Value*0.0980665019960652); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable KilogramForceMeters. + /// + public static Torque? FromKilogramForceMeters(double? kilogramforcemeters) + { + if (kilogramforcemeters.HasValue) + { + return new Torque(kilogramforcemeters.Value*9.80665019960652); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable KilogramForceMillimeters. + /// + public static Torque? FromKilogramForceMillimeters(double? kilogramforcemillimeters) + { + if (kilogramforcemillimeters.HasValue) + { + return new Torque(kilogramforcemillimeters.Value*0.00980665019960652); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable KilonewtonCentimeters. + /// + public static Torque? FromKilonewtonCentimeters(double? kilonewtoncentimeters) + { + if (kilonewtoncentimeters.HasValue) + { + return new Torque((kilonewtoncentimeters.Value*0.01) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable KilonewtonMeters. + /// + public static Torque? FromKilonewtonMeters(double? kilonewtonmeters) + { + if (kilonewtonmeters.HasValue) + { + return new Torque((kilonewtonmeters.Value) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable KilonewtonMillimeters. + /// + public static Torque? FromKilonewtonMillimeters(double? kilonewtonmillimeters) + { + if (kilonewtonmillimeters.HasValue) + { + return new Torque((kilonewtonmillimeters.Value*0.001) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable KilopoundForceFeet. + /// + public static Torque? FromKilopoundForceFeet(double? kilopoundforcefeet) + { + if (kilopoundforcefeet.HasValue) + { + return new Torque((kilopoundforcefeet.Value*1.3558180656) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable KilopoundForceInches. + /// + public static Torque? FromKilopoundForceInches(double? kilopoundforceinches) + { + if (kilopoundforceinches.HasValue) + { + return new Torque((kilopoundforceinches.Value*0.1129848388) * 1e3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable NewtonCentimeters. + /// + public static Torque? FromNewtonCentimeters(double? newtoncentimeters) + { + if (newtoncentimeters.HasValue) + { + return new Torque(newtoncentimeters.Value*0.01); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable NewtonMeters. + /// + public static Torque? FromNewtonMeters(double? newtonmeters) + { + if (newtonmeters.HasValue) + { + return new Torque(newtonmeters.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable NewtonMillimeters. + /// + public static Torque? FromNewtonMillimeters(double? newtonmillimeters) + { + if (newtonmillimeters.HasValue) + { + return new Torque(newtonmillimeters.Value*0.001); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable PoundForceFeet. + /// + public static Torque? FromPoundForceFeet(double? poundforcefeet) + { + if (poundforcefeet.HasValue) + { + return new Torque(poundforcefeet.Value*1.3558180656); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable PoundForceInches. + /// + public static Torque? FromPoundForceInches(double? poundforceinches) + { + if (poundforceinches.HasValue) + { + return new Torque(poundforceinches.Value*0.1129848388); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable TonneForceCentimeters. + /// + public static Torque? FromTonneForceCentimeters(double? tonneforcecentimeters) + { + if (tonneforcecentimeters.HasValue) + { + return new Torque(tonneforcecentimeters.Value*98.0665019960652); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable TonneForceMeters. + /// + public static Torque? FromTonneForceMeters(double? tonneforcemeters) + { + if (tonneforcemeters.HasValue) + { + return new Torque(tonneforcemeters.Value*9806.65019960653); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable TonneForceMillimeters. + /// + public static Torque? FromTonneForceMillimeters(double? tonneforcemillimeters) + { + if (tonneforcemillimeters.HasValue) + { + return new Torque(tonneforcemillimeters.Value*9.80665019960652); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs b/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs index 263cb8ad92..2f844c5d9b 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs @@ -80,6 +80,22 @@ public static VitaminA FromInternationalUnits(double internationalunits) } + /// + /// Get nullable VitaminA from nullable InternationalUnits. + /// + public static VitaminA? FromInternationalUnits(double? internationalunits) + { + if (internationalunits.HasValue) + { + return new VitaminA(internationalunits.Value); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs index dfe189db07..7992b3ace3 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs @@ -530,6 +530,442 @@ public static Volume FromUsTeaspoons(double usteaspoons) } + /// + /// Get nullable Volume from nullable AuTablespoons. + /// + public static Volume? FromAuTablespoons(double? autablespoons) + { + if (autablespoons.HasValue) + { + return new Volume(autablespoons.Value*2e-5); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable Centiliters. + /// + public static Volume? FromCentiliters(double? centiliters) + { + if (centiliters.HasValue) + { + return new Volume((centiliters.Value/1e3) * 1e-2d); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable CubicCentimeters. + /// + public static Volume? FromCubicCentimeters(double? cubiccentimeters) + { + if (cubiccentimeters.HasValue) + { + return new Volume(cubiccentimeters.Value/1e6); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable CubicDecimeters. + /// + public static Volume? FromCubicDecimeters(double? cubicdecimeters) + { + if (cubicdecimeters.HasValue) + { + return new Volume(cubicdecimeters.Value/1e3); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable CubicFeet. + /// + public static Volume? FromCubicFeet(double? cubicfeet) + { + if (cubicfeet.HasValue) + { + return new Volume(cubicfeet.Value*0.0283168); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable CubicInches. + /// + public static Volume? FromCubicInches(double? cubicinches) + { + if (cubicinches.HasValue) + { + return new Volume(cubicinches.Value*1.6387*1e-5); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable CubicKilometers. + /// + public static Volume? FromCubicKilometers(double? cubickilometers) + { + if (cubickilometers.HasValue) + { + return new Volume(cubickilometers.Value*1e9); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable CubicMeters. + /// + public static Volume? FromCubicMeters(double? cubicmeters) + { + if (cubicmeters.HasValue) + { + return new Volume(cubicmeters.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable CubicMicrometers. + /// + public static Volume? FromCubicMicrometers(double? cubicmicrometers) + { + if (cubicmicrometers.HasValue) + { + return new Volume(cubicmicrometers.Value/1e18); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable CubicMiles. + /// + public static Volume? FromCubicMiles(double? cubicmiles) + { + if (cubicmiles.HasValue) + { + return new Volume(cubicmiles.Value*4.16818183*1e9); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable CubicMillimeters. + /// + public static Volume? FromCubicMillimeters(double? cubicmillimeters) + { + if (cubicmillimeters.HasValue) + { + return new Volume(cubicmillimeters.Value/1e9); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable CubicYards. + /// + public static Volume? FromCubicYards(double? cubicyards) + { + if (cubicyards.HasValue) + { + return new Volume(cubicyards.Value*0.764554858); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable Deciliters. + /// + public static Volume? FromDeciliters(double? deciliters) + { + if (deciliters.HasValue) + { + return new Volume((deciliters.Value/1e3) * 1e-1d); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable Hectoliters. + /// + public static Volume? FromHectoliters(double? hectoliters) + { + if (hectoliters.HasValue) + { + return new Volume((hectoliters.Value/1e3) * 1e2d); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable ImperialGallons. + /// + public static Volume? FromImperialGallons(double? imperialgallons) + { + if (imperialgallons.HasValue) + { + return new Volume(imperialgallons.Value*0.00454609000000181429905810072407); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable ImperialOunces. + /// + public static Volume? FromImperialOunces(double? imperialounces) + { + if (imperialounces.HasValue) + { + return new Volume(imperialounces.Value*2.8413062499962901241875439064617e-5); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable Liters. + /// + public static Volume? FromLiters(double? liters) + { + if (liters.HasValue) + { + return new Volume(liters.Value/1e3); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable MetricCups. + /// + public static Volume? FromMetricCups(double? metriccups) + { + if (metriccups.HasValue) + { + return new Volume(metriccups.Value*0.00025); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable MetricTeaspoons. + /// + public static Volume? FromMetricTeaspoons(double? metricteaspoons) + { + if (metricteaspoons.HasValue) + { + return new Volume(metricteaspoons.Value*0.5e-5); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable Milliliters. + /// + public static Volume? FromMilliliters(double? milliliters) + { + if (milliliters.HasValue) + { + return new Volume((milliliters.Value/1e3) * 1e-3d); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable Tablespoons. + /// + public static Volume? FromTablespoons(double? tablespoons) + { + if (tablespoons.HasValue) + { + return new Volume(tablespoons.Value*1.478676478125e-5); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable Teaspoons. + /// + public static Volume? FromTeaspoons(double? teaspoons) + { + if (teaspoons.HasValue) + { + return new Volume(teaspoons.Value*4.92892159375e-6); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable UkTablespoons. + /// + public static Volume? FromUkTablespoons(double? uktablespoons) + { + if (uktablespoons.HasValue) + { + return new Volume(uktablespoons.Value*1.5e-5); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable UsCustomaryCups. + /// + public static Volume? FromUsCustomaryCups(double? uscustomarycups) + { + if (uscustomarycups.HasValue) + { + return new Volume(uscustomarycups.Value*0.0002365882365); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable UsGallons. + /// + public static Volume? FromUsGallons(double? usgallons) + { + if (usgallons.HasValue) + { + return new Volume(usgallons.Value*0.00378541); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable UsLegalCups. + /// + public static Volume? FromUsLegalCups(double? uslegalcups) + { + if (uslegalcups.HasValue) + { + return new Volume(uslegalcups.Value*0.00024); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable UsOunces. + /// + public static Volume? FromUsOunces(double? usounces) + { + if (usounces.HasValue) + { + return new Volume(usounces.Value*2.957352956253760505068307980135e-5); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable UsTablespoons. + /// + public static Volume? FromUsTablespoons(double? ustablespoons) + { + if (ustablespoons.HasValue) + { + return new Volume(ustablespoons.Value*1.478676478125e-5); + } + else + { + return null; + } + } + + /// + /// Get nullable Volume from nullable UsTeaspoons. + /// + public static Volume? FromUsTeaspoons(double? usteaspoons) + { + if (usteaspoons.HasValue) + { + return new Volume(usteaspoons.Value*4.92892159375e-6); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 index e0ba4c35eb..c7a161ad83 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 @@ -72,10 +72,10 @@ namespace UnitsNet $propertyName = $unit.PluralName; $obsoleteAttribute = GetObsoleteAttribute($unit); if ($obsoleteAttribute) - { - $obsoleteAttribute = "`r`n " + $obsoleteAttribute; # apply padding to conformance with code format in this page - } - + { + $obsoleteAttribute = "`r`n " + $obsoleteAttribute; # apply padding to conformance with code format in this page + } + $fromBaseToUnitFunc = $unit.FromBaseToUnitFunc.Replace("x", $baseUnitFieldName);@" /// @@ -107,6 +107,26 @@ namespace UnitsNet return new $className($func); } +"@; }@" + +"@; foreach ($unit in $units) { + $valueParamName = $unit.PluralName.ToLowerInvariant(); + $func = $unit.FromUnitToBaseFunc.Replace("x", "$($valueParamName).Value");@" + /// + /// Get nullable $className from nullable $($unit.PluralName). + /// + public static $($className)? From$($unit.PluralName)(double? $valueParamName) + { + if ($($valueParamName).HasValue) + { + return new $className($func); + } + else + { + return null; + } + } + "@; }@" /// diff --git a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 index 3eadcdfb21..f86381df40 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 @@ -194,6 +194,21 @@ namespace UnitsNet.Tests $className $baseUnitVariableName = $className.From$baseUnitPluralName(1); Assert.IsFalse($baseUnitVariableName.Equals(null)); } + + [Test] + public void StaticConstructorWithNullReturnsNull() + { + $($className)? $baseUnitVariableName = $className.From$baseUnitPluralName(null); + Assert.IsTrue($baseUnitVariableName.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + $($className)? $baseUnitVariableName = $className.From$baseUnitPluralName(value); + Assert.IsTrue($($baseUnitVariableName).HasValue); + } } } "@; From 7a61bc568b3585b3fc06f3899aa845a01372abd3 Mon Sep 17 00:00:00 2001 From: Erik Ovegard Date: Tue, 23 Feb 2016 13:29:58 +0100 Subject: [PATCH 2/5] Added nullable overload on .From() --- .../UnitsNetJsonConverter.cs | 5 +- .../GeneratedCode/AccelerationTestsBase.g.cs | 15 +++ .../AmplitudeRatioTestsBase.g.cs | 15 +++ .../GeneratedCode/AngleTestsBase.g.cs | 15 +++ .../GeneratedCode/AreaTestsBase.g.cs | 15 +++ .../GeneratedCode/DensityTestsBase.g.cs | 15 +++ .../GeneratedCode/DurationTestsBase.g.cs | 15 +++ .../ElectricCurrentTestsBase.g.cs | 15 +++ .../ElectricPotentialTestsBase.g.cs | 15 +++ .../ElectricResistanceTestsBase.g.cs | 15 +++ .../GeneratedCode/EnergyTestsBase.g.cs | 15 +++ .../GeneratedCode/FlowTestsBase.g.cs | 15 +++ .../ForceChangeRateTestsBase.g.cs | 15 +++ .../GeneratedCode/ForceTestsBase.g.cs | 15 +++ .../GeneratedCode/FrequencyTestsBase.g.cs | 15 +++ .../GeneratedCode/InformationTestsBase.g.cs | 15 +++ .../KinematicViscosityTestsBase.g.cs | 15 +++ .../GeneratedCode/LengthTestsBase.g.cs | 15 +++ .../GeneratedCode/LevelTestsBase.g.cs | 15 +++ .../GeneratedCode/MassFlowTestsBase.g.cs | 15 +++ .../GeneratedCode/MassTestsBase.g.cs | 15 +++ .../GeneratedCode/PowerRatioTestsBase.g.cs | 15 +++ .../GeneratedCode/PowerTestsBase.g.cs | 15 +++ .../PressureChangeRateTestsBase.g.cs | 15 +++ .../GeneratedCode/PressureTestsBase.g.cs | 15 +++ .../GeneratedCode/RatioTestsBase.g.cs | 15 +++ .../RotationalSpeedTestsBase.g.cs | 15 +++ .../SpecificEnergyTestsBase.g.cs | 15 +++ .../SpecificWeightTestsBase.g.cs | 15 +++ .../GeneratedCode/SpeedTestsBase.g.cs | 15 +++ .../TemperatureChangeRateTestsBase.g.cs | 15 +++ .../GeneratedCode/TemperatureTestsBase.g.cs | 15 +++ .../GeneratedCode/TorqueTestsBase.g.cs | 15 +++ .../GeneratedCode/VitaminATestsBase.g.cs | 15 +++ .../GeneratedCode/VolumeTestsBase.g.cs | 15 +++ .../UnitClasses/Acceleration.g.cs | 46 +++++++-- .../UnitClasses/AmplitudeRatio.g.cs | 38 +++++-- UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs | 52 ++++++++-- UnitsNet/GeneratedCode/UnitClasses/Area.g.cs | 52 ++++++++-- .../GeneratedCode/UnitClasses/Density.g.cs | 52 ++++++++-- .../GeneratedCode/UnitClasses/Duration.g.cs | 52 ++++++++-- .../UnitClasses/ElectricCurrent.g.cs | 44 +++++++-- .../UnitClasses/ElectricPotential.g.cs | 42 ++++++-- .../UnitClasses/ElectricResistance.g.cs | 38 +++++-- .../GeneratedCode/UnitClasses/Energy.g.cs | 58 +++++++++-- UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs | 44 +++++++-- UnitsNet/GeneratedCode/UnitClasses/Force.g.cs | 48 +++++++-- .../UnitClasses/ForceChangeRate.g.cs | 34 +++++-- .../GeneratedCode/UnitClasses/Frequency.g.cs | 48 +++++++-- .../UnitClasses/Information.g.cs | 84 ++++++++++++++-- .../UnitClasses/KinematicViscosity.g.cs | 48 +++++++-- .../GeneratedCode/UnitClasses/Length.g.cs | 60 ++++++++++-- UnitsNet/GeneratedCode/UnitClasses/Level.g.cs | 36 +++++-- UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs | 66 +++++++++++-- .../GeneratedCode/UnitClasses/MassFlow.g.cs | 52 ++++++++-- UnitsNet/GeneratedCode/UnitClasses/Power.g.cs | 64 ++++++++++-- .../GeneratedCode/UnitClasses/PowerRatio.g.cs | 36 +++++-- .../GeneratedCode/UnitClasses/Pressure.g.cs | 98 +++++++++++++++++-- .../UnitClasses/PressureChangeRate.g.cs | 40 ++++++-- UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs | 44 +++++++-- .../UnitClasses/RotationalSpeed.g.cs | 48 +++++++-- .../UnitClasses/SpecificEnergy.g.cs | 48 +++++++-- .../UnitClasses/SpecificWeight.g.cs | 64 ++++++++++-- UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs | 56 +++++++++-- .../UnitClasses/Temperature.g.cs | 48 +++++++-- .../UnitClasses/TemperatureChangeRate.g.cs | 50 ++++++++-- .../GeneratedCode/UnitClasses/Torque.g.cs | 64 ++++++++++-- .../GeneratedCode/UnitClasses/VitaminA.g.cs | 34 +++++-- .../GeneratedCode/UnitClasses/Volume.g.cs | 90 +++++++++++++++-- .../Include-GenerateUnitClassSourceCode.ps1 | 36 +++++-- ...de-GenerateUnitTestBaseClassSourceCode.ps1 | 15 +++ 71 files changed, 2133 insertions(+), 211 deletions(-) diff --git a/UnitsNet.Serialization.JsonNet/UnitsNetJsonConverter.cs b/UnitsNet.Serialization.JsonNet/UnitsNetJsonConverter.cs index b793c3f452..6e3eef62dd 100644 --- a/UnitsNet.Serialization.JsonNet/UnitsNetJsonConverter.cs +++ b/UnitsNet.Serialization.JsonNet/UnitsNetJsonConverter.cs @@ -93,7 +93,10 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist object unit = Enum.Parse(reflectedUnitEnumType, unitEnumValue); // Mass.From() method, assume no overloads exist - MethodInfo fromMethod = reflectedUnitType.GetMethod("From"); + MethodInfo fromMethod = (from m in reflectedUnitType.GetMethods() + where m.Name.Equals("From", StringComparison.InvariantCulture) && + !m.ReturnType.IsGenericType // we want the non nullable type + select m).Single(); // Ex: Mass.From(55, MassUnit.Gram) // TODO: there is a possible loss of precision if base value requires higher precision than double can represent. diff --git a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs index 10ffd9a633..5e4b444891 100644 --- a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs @@ -207,6 +207,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(meterpersecondsquared.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Acceleration? meterpersecondsquared = Acceleration.From(null,AccelerationUnit.MeterPerSecondSquared); + Assert.IsTrue(meterpersecondsquared.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Acceleration? meterpersecondsquared = Acceleration.From(value,AccelerationUnit.MeterPerSecondSquared); + Assert.IsTrue(meterpersecondsquared.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs index 41aaf1a656..f1212fe2e1 100644 --- a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs @@ -187,6 +187,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(decibelvolt.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + AmplitudeRatio? decibelvolt = AmplitudeRatio.From(null,AmplitudeRatioUnit.DecibelVolt); + Assert.IsTrue(decibelvolt.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + AmplitudeRatio? decibelvolt = AmplitudeRatio.From(value,AmplitudeRatioUnit.DecibelVolt); + Assert.IsTrue(decibelvolt.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs index 4c8d196adb..35132cf429 100644 --- a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs @@ -225,6 +225,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(degree.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Angle? degree = Angle.From(null,AngleUnit.Degree); + Assert.IsTrue(degree.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Angle? degree = Angle.From(value,AngleUnit.Degree); + Assert.IsTrue(degree.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs index b4b35fada2..343b4d4d54 100644 --- a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs @@ -225,6 +225,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(squaremeter.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Area? squaremeter = Area.From(null,AreaUnit.SquareMeter); + Assert.IsTrue(squaremeter.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Area? squaremeter = Area.From(value,AreaUnit.SquareMeter); + Assert.IsTrue(squaremeter.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs index a7380475df..85c69e5c3c 100644 --- a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs @@ -225,6 +225,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(kilogrampercubicmeter.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Density? kilogrampercubicmeter = Density.From(null,DensityUnit.KilogramPerCubicMeter); + Assert.IsTrue(kilogrampercubicmeter.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Density? kilogrampercubicmeter = Density.From(value,DensityUnit.KilogramPerCubicMeter); + Assert.IsTrue(kilogrampercubicmeter.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs index 285cc6ba9c..79328746ce 100644 --- a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs @@ -225,6 +225,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(second.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Duration? second = Duration.From(null,DurationUnit.Second); + Assert.IsTrue(second.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Duration? second = Duration.From(value,DurationUnit.Second); + Assert.IsTrue(second.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs index e8e8d766ec..ac377769f4 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs @@ -201,6 +201,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(ampere.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + ElectricCurrent? ampere = ElectricCurrent.From(null,ElectricCurrentUnit.Ampere); + Assert.IsTrue(ampere.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + ElectricCurrent? ampere = ElectricCurrent.From(value,ElectricCurrentUnit.Ampere); + Assert.IsTrue(ampere.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs index ee57c93cc7..93aac20ece 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs @@ -195,6 +195,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(volt.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + ElectricPotential? volt = ElectricPotential.From(null,ElectricPotentialUnit.Volt); + Assert.IsTrue(volt.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + ElectricPotential? volt = ElectricPotential.From(value,ElectricPotentialUnit.Volt); + Assert.IsTrue(volt.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs index 29995547c6..50707a586d 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs @@ -183,6 +183,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(ohm.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + ElectricResistance? ohm = ElectricResistance.From(null,ElectricResistanceUnit.Ohm); + Assert.IsTrue(ohm.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + ElectricResistance? ohm = ElectricResistance.From(value,ElectricResistanceUnit.Ohm); + Assert.IsTrue(ohm.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs index d9caf1c72f..f38fc3f74b 100644 --- a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs @@ -243,6 +243,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(joule.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Energy? joule = Energy.From(null,EnergyUnit.Joule); + Assert.IsTrue(joule.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Energy? joule = Energy.From(value,EnergyUnit.Joule); + Assert.IsTrue(joule.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs index 8401c492da..257bb0cf4c 100644 --- a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs @@ -201,6 +201,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(cubicmeterpersecond.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Flow? cubicmeterpersecond = Flow.From(null,FlowUnit.CubicMeterPerSecond); + Assert.IsTrue(cubicmeterpersecond.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Flow? cubicmeterpersecond = Flow.From(value,FlowUnit.CubicMeterPerSecond); + Assert.IsTrue(cubicmeterpersecond.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs index aa23722991..c6e28b48e0 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs @@ -171,6 +171,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(newtonpersecond.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + ForceChangeRate? newtonpersecond = ForceChangeRate.From(null,ForceChangeRateUnit.NewtonPerSecond); + Assert.IsTrue(newtonpersecond.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + ForceChangeRate? newtonpersecond = ForceChangeRate.From(value,ForceChangeRateUnit.NewtonPerSecond); + Assert.IsTrue(newtonpersecond.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs index edbbbab988..afbce616a8 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs @@ -213,6 +213,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(newton.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Force? newton = Force.From(null,ForceUnit.Newton); + Assert.IsTrue(newton.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Force? newton = Force.From(value,ForceUnit.Newton); + Assert.IsTrue(newton.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs index b4325faba3..d8dee4f3ae 100644 --- a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs @@ -213,6 +213,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(hertz.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Frequency? hertz = Frequency.From(null,FrequencyUnit.Hertz); + Assert.IsTrue(hertz.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Frequency? hertz = Frequency.From(value,FrequencyUnit.Hertz); + Assert.IsTrue(hertz.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs index 878731d684..e50d3e5272 100644 --- a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs @@ -321,6 +321,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(bit.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Information? bit = Information.From(null,InformationUnit.Bit); + Assert.IsTrue(bit.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Information? bit = Information.From(value,InformationUnit.Bit); + Assert.IsTrue(bit.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs index 96541fa0dc..0a870f80f3 100644 --- a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs @@ -213,6 +213,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(squaremeterpersecond.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + KinematicViscosity? squaremeterpersecond = KinematicViscosity.From(null,KinematicViscosityUnit.SquareMeterPerSecond); + Assert.IsTrue(squaremeterpersecond.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + KinematicViscosity? squaremeterpersecond = KinematicViscosity.From(value,KinematicViscosityUnit.SquareMeterPerSecond); + Assert.IsTrue(squaremeterpersecond.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs index 59c329c67d..7c983435ee 100644 --- a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs @@ -249,6 +249,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(meter.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Length? meter = Length.From(null,LengthUnit.Meter); + Assert.IsTrue(meter.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Length? meter = Length.From(value,LengthUnit.Meter); + Assert.IsTrue(meter.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs index b30ed68352..4576c183bd 100644 --- a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs @@ -181,6 +181,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(decibel.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Level? decibel = Level.From(null,LevelUnit.Decibel); + Assert.IsTrue(decibel.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Level? decibel = Level.From(value,LevelUnit.Decibel); + Assert.IsTrue(decibel.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs index 3b4bff1124..ff21eed02e 100644 --- a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs @@ -225,6 +225,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(grampersecond.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + MassFlow? grampersecond = MassFlow.From(null,MassFlowUnit.GramPerSecond); + Assert.IsTrue(grampersecond.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + MassFlow? grampersecond = MassFlow.From(value,MassFlowUnit.GramPerSecond); + Assert.IsTrue(grampersecond.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs index 7d48a6b953..8b0d947352 100644 --- a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs @@ -267,6 +267,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(kilogram.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Mass? kilogram = Mass.From(null,MassUnit.Kilogram); + Assert.IsTrue(kilogram.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Mass? kilogram = Mass.From(value,MassUnit.Kilogram); + Assert.IsTrue(kilogram.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs index ac8ce52acf..b58a57d61d 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs @@ -181,6 +181,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(decibelwatt.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + PowerRatio? decibelwatt = PowerRatio.From(null,PowerRatioUnit.DecibelWatt); + Assert.IsTrue(decibelwatt.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + PowerRatio? decibelwatt = PowerRatio.From(value,PowerRatioUnit.DecibelWatt); + Assert.IsTrue(decibelwatt.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs index 154a1c999b..00d2d79ea6 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs @@ -261,6 +261,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(watt.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Power? watt = Power.From(null,PowerUnit.Watt); + Assert.IsTrue(watt.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Power? watt = Power.From(value,PowerUnit.Watt); + Assert.IsTrue(watt.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs index aa4fab3bad..c6964efe33 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs @@ -189,6 +189,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(pascalpersecond.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + PressureChangeRate? pascalpersecond = PressureChangeRate.From(null,PressureChangeRateUnit.PascalPerSecond); + Assert.IsTrue(pascalpersecond.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + PressureChangeRate? pascalpersecond = PressureChangeRate.From(value,PressureChangeRateUnit.PascalPerSecond); + Assert.IsTrue(pascalpersecond.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs index 6e2c3e906f..a8c637fb79 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs @@ -363,6 +363,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(pascal.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Pressure? pascal = Pressure.From(null,PressureUnit.Pascal); + Assert.IsTrue(pascal.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Pressure? pascal = Pressure.From(value,PressureUnit.Pascal); + Assert.IsTrue(pascal.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs index 4c6d82ff45..689cf58566 100644 --- a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs @@ -201,6 +201,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(decimalfraction.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Ratio? decimalfraction = Ratio.From(null,RatioUnit.DecimalFraction); + Assert.IsTrue(decimalfraction.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Ratio? decimalfraction = Ratio.From(value,RatioUnit.DecimalFraction); + Assert.IsTrue(decimalfraction.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs index 45b86fc263..4134e619f8 100644 --- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs @@ -213,6 +213,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(radianpersecond.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + RotationalSpeed? radianpersecond = RotationalSpeed.From(null,RotationalSpeedUnit.RadianPerSecond); + Assert.IsTrue(radianpersecond.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + RotationalSpeed? radianpersecond = RotationalSpeed.From(value,RotationalSpeedUnit.RadianPerSecond); + Assert.IsTrue(radianpersecond.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs index 8bd167a3ca..ddd6854406 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs @@ -213,6 +213,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(jouleperkilogram.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + SpecificEnergy? jouleperkilogram = SpecificEnergy.From(null,SpecificEnergyUnit.JoulePerKilogram); + Assert.IsTrue(jouleperkilogram.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + SpecificEnergy? jouleperkilogram = SpecificEnergy.From(value,SpecificEnergyUnit.JoulePerKilogram); + Assert.IsTrue(jouleperkilogram.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs index 281c71c1cc..f365d11f1f 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs @@ -261,6 +261,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(newtonpercubicmeter.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + SpecificWeight? newtonpercubicmeter = SpecificWeight.From(null,SpecificWeightUnit.NewtonPerCubicMeter); + Assert.IsTrue(newtonpercubicmeter.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + SpecificWeight? newtonpercubicmeter = SpecificWeight.From(value,SpecificWeightUnit.NewtonPerCubicMeter); + Assert.IsTrue(newtonpercubicmeter.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs index 83776fd793..fc39cf0a3c 100644 --- a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs @@ -237,6 +237,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(meterpersecond.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Speed? meterpersecond = Speed.From(null,SpeedUnit.MeterPerSecond); + Assert.IsTrue(meterpersecond.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Speed? meterpersecond = Speed.From(value,SpeedUnit.MeterPerSecond); + Assert.IsTrue(meterpersecond.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs index cac74d03f6..e14c292804 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs @@ -219,6 +219,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(degreecelsiuspersecond.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + TemperatureChangeRate? degreecelsiuspersecond = TemperatureChangeRate.From(null,TemperatureChangeRateUnit.DegreeCelsiusPerSecond); + Assert.IsTrue(degreecelsiuspersecond.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + TemperatureChangeRate? degreecelsiuspersecond = TemperatureChangeRate.From(value,TemperatureChangeRateUnit.DegreeCelsiusPerSecond); + Assert.IsTrue(degreecelsiuspersecond.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs index 3c13f14cc9..79ee5738ee 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs @@ -213,6 +213,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(kelvin.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Temperature? kelvin = Temperature.From(null,TemperatureUnit.Kelvin); + Assert.IsTrue(kelvin.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Temperature? kelvin = Temperature.From(value,TemperatureUnit.Kelvin); + Assert.IsTrue(kelvin.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs index 99e6f82678..6c74acf5ce 100644 --- a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs @@ -261,6 +261,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(newtonmeter.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Torque? newtonmeter = Torque.From(null,TorqueUnit.NewtonMeter); + Assert.IsTrue(newtonmeter.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Torque? newtonmeter = Torque.From(value,TorqueUnit.NewtonMeter); + Assert.IsTrue(newtonmeter.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs index 0e9cf4d3a2..ba02b17ec9 100644 --- a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs @@ -171,6 +171,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(internationalunit.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + VitaminA? internationalunit = VitaminA.From(null,VitaminAUnit.InternationalUnit); + Assert.IsTrue(internationalunit.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + VitaminA? internationalunit = VitaminA.From(value,VitaminAUnit.InternationalUnit); + Assert.IsTrue(internationalunit.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs index 1ffa990ac2..09a90208da 100644 --- a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs @@ -339,6 +339,21 @@ public void StaticConstructorWithNullReturnsNull() Assert.IsTrue(cubicmeter.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + Volume? cubicmeter = Volume.From(null,VolumeUnit.CubicMeter); + Assert.IsTrue(cubicmeter.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + Volume? cubicmeter = Volume.From(value,VolumeUnit.CubicMeter); + Assert.IsTrue(cubicmeter.HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs index ca83e28819..fa02973607 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs @@ -312,6 +312,40 @@ public static Acceleration From(double value, AccelerationUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Acceleration unit value. + public static Acceleration? From(double? value, AccelerationUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case AccelerationUnit.CentimeterPerSecondSquared: + return FromCentimeterPerSecondSquared(value.Value); + case AccelerationUnit.DecimeterPerSecondSquared: + return FromDecimeterPerSecondSquared(value.Value); + case AccelerationUnit.KilometerPerSecondSquared: + return FromKilometerPerSecondSquared(value.Value); + case AccelerationUnit.MeterPerSecondSquared: + return FromMeterPerSecondSquared(value.Value); + case AccelerationUnit.MicrometerPerSecondSquared: + return FromMicrometerPerSecondSquared(value.Value); + case AccelerationUnit.MillimeterPerSecondSquared: + return FromMillimeterPerSecondSquared(value.Value); + case AccelerationUnit.NanometerPerSecondSquared: + return FromNanometerPerSecondSquared(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -477,14 +511,14 @@ public double As(AccelerationUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Acceleration Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs index 40a7ee2ab8..cf7ad3dd0f 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs @@ -180,6 +180,32 @@ public static AmplitudeRatio From(double value, AmplitudeRatioUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// AmplitudeRatio unit value. + public static AmplitudeRatio? From(double? value, AmplitudeRatioUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case AmplitudeRatioUnit.DecibelMicrovolt: + return FromDecibelMicrovolts(value.Value); + case AmplitudeRatioUnit.DecibelMillivolt: + return FromDecibelMillivolts(value.Value); + case AmplitudeRatioUnit.DecibelVolt: + return FromDecibelVolts(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -345,14 +371,14 @@ public double As(AmplitudeRatioUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static AmplitudeRatio Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs index 8fdc2e5831..9be13e518d 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs @@ -411,6 +411,46 @@ public static Angle From(double value, AngleUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Angle unit value. + public static Angle? From(double? value, AngleUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case AngleUnit.Arcminute: + return FromArcminutes(value.Value); + case AngleUnit.Arcsecond: + return FromArcseconds(value.Value); + case AngleUnit.Centiradian: + return FromCentiradians(value.Value); + case AngleUnit.Deciradian: + return FromDeciradians(value.Value); + case AngleUnit.Degree: + return FromDegrees(value.Value); + case AngleUnit.Gradian: + return FromGradians(value.Value); + case AngleUnit.Microradian: + return FromMicroradians(value.Value); + case AngleUnit.Milliradian: + return FromMilliradians(value.Value); + case AngleUnit.Nanoradian: + return FromNanoradians(value.Value); + case AngleUnit.Radian: + return FromRadians(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -582,14 +622,14 @@ public double As(AngleUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Angle Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs index 315ea9caff..eef47ba75f 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs @@ -411,6 +411,46 @@ public static Area From(double value, AreaUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Area unit value. + public static Area? From(double? value, AreaUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case AreaUnit.SquareCentimeter: + return FromSquareCentimeters(value.Value); + case AreaUnit.SquareDecimeter: + return FromSquareDecimeters(value.Value); + case AreaUnit.SquareFoot: + return FromSquareFeet(value.Value); + case AreaUnit.SquareInch: + return FromSquareInches(value.Value); + case AreaUnit.SquareKilometer: + return FromSquareKilometers(value.Value); + case AreaUnit.SquareMeter: + return FromSquareMeters(value.Value); + case AreaUnit.SquareMicrometer: + return FromSquareMicrometers(value.Value); + case AreaUnit.SquareMile: + return FromSquareMiles(value.Value); + case AreaUnit.SquareMillimeter: + return FromSquareMillimeters(value.Value); + case AreaUnit.SquareYard: + return FromSquareYards(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -582,14 +622,14 @@ public double As(AreaUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Area Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs index 1b3bd24bea..4a7559a051 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs @@ -411,6 +411,46 @@ public static Density From(double value, DensityUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Density unit value. + public static Density? From(double? value, DensityUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case DensityUnit.KilogramPerCubicCentimeter: + return FromKilogramsPerCubicCentimeter(value.Value); + case DensityUnit.KilogramPerCubicMeter: + return FromKilogramsPerCubicMeter(value.Value); + case DensityUnit.KilogramPerCubicMillimeter: + return FromKilogramsPerCubicMillimeter(value.Value); + case DensityUnit.KilopoundPerCubicFoot: + return FromKilopoundsPerCubicFoot(value.Value); + case DensityUnit.KilopoundPerCubicInch: + return FromKilopoundsPerCubicInch(value.Value); + case DensityUnit.PoundPerCubicFoot: + return FromPoundsPerCubicFoot(value.Value); + case DensityUnit.PoundPerCubicInch: + return FromPoundsPerCubicInch(value.Value); + case DensityUnit.TonnePerCubicCentimeter: + return FromTonnesPerCubicCentimeter(value.Value); + case DensityUnit.TonnePerCubicMeter: + return FromTonnesPerCubicMeter(value.Value); + case DensityUnit.TonnePerCubicMillimeter: + return FromTonnesPerCubicMillimeter(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -582,14 +622,14 @@ public double As(DensityUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Density Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs index ba8c12f712..164b6479df 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs @@ -411,6 +411,46 @@ public static Duration From(double value, DurationUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Duration unit value. + public static Duration? From(double? value, DurationUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case DurationUnit.Day: + return FromDays(value.Value); + case DurationUnit.Hour: + return FromHours(value.Value); + case DurationUnit.Microsecond: + return FromMicroseconds(value.Value); + case DurationUnit.Millisecond: + return FromMilliseconds(value.Value); + case DurationUnit.Minute: + return FromMinutes(value.Value); + case DurationUnit.Month: + return FromMonths(value.Value); + case DurationUnit.Nanosecond: + return FromNanoseconds(value.Value); + case DurationUnit.Second: + return FromSeconds(value.Value); + case DurationUnit.Week: + return FromWeeks(value.Value); + case DurationUnit.Year: + return FromYears(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -582,14 +622,14 @@ public double As(DurationUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Duration Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs index d1e4cfecf5..a541aefd59 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs @@ -279,6 +279,38 @@ public static ElectricCurrent From(double value, ElectricCurrentUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// ElectricCurrent unit value. + public static ElectricCurrent? From(double? value, ElectricCurrentUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case ElectricCurrentUnit.Ampere: + return FromAmperes(value.Value); + case ElectricCurrentUnit.Kiloampere: + return FromKiloamperes(value.Value); + case ElectricCurrentUnit.Megaampere: + return FromMegaamperes(value.Value); + case ElectricCurrentUnit.Microampere: + return FromMicroamperes(value.Value); + case ElectricCurrentUnit.Milliampere: + return FromMilliamperes(value.Value); + case ElectricCurrentUnit.Nanoampere: + return FromNanoamperes(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -442,14 +474,14 @@ public double As(ElectricCurrentUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static ElectricCurrent Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs index df77576fd9..3aac6718db 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs @@ -246,6 +246,36 @@ public static ElectricPotential From(double value, ElectricPotentialUnit fromUni } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// ElectricPotential unit value. + public static ElectricPotential? From(double? value, ElectricPotentialUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case ElectricPotentialUnit.Kilovolt: + return FromKilovolts(value.Value); + case ElectricPotentialUnit.Megavolt: + return FromMegavolts(value.Value); + case ElectricPotentialUnit.Microvolt: + return FromMicrovolts(value.Value); + case ElectricPotentialUnit.Millivolt: + return FromMillivolts(value.Value); + case ElectricPotentialUnit.Volt: + return FromVolts(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -407,14 +437,14 @@ public double As(ElectricPotentialUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static ElectricPotential Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs index 4f10995161..57bdb4fcb1 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs @@ -180,6 +180,32 @@ public static ElectricResistance From(double value, ElectricResistanceUnit fromU } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// ElectricResistance unit value. + public static ElectricResistance? From(double? value, ElectricResistanceUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case ElectricResistanceUnit.Kiloohm: + return FromKiloohms(value.Value); + case ElectricResistanceUnit.Megaohm: + return FromMegaohms(value.Value); + case ElectricResistanceUnit.Ohm: + return FromOhms(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -337,14 +363,14 @@ public double As(ElectricResistanceUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static ElectricResistance Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs index 0925f391fd..a3bade27df 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs @@ -510,6 +510,52 @@ public static Energy From(double value, EnergyUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Energy unit value. + public static Energy? From(double? value, EnergyUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case EnergyUnit.BritishThermalUnit: + return FromBritishThermalUnits(value.Value); + case EnergyUnit.Calorie: + return FromCalories(value.Value); + case EnergyUnit.ElectronVolt: + return FromElectronVolts(value.Value); + case EnergyUnit.Erg: + return FromErgs(value.Value); + case EnergyUnit.FootPound: + return FromFootPounds(value.Value); + case EnergyUnit.GigawattHour: + return FromGigawattHours(value.Value); + case EnergyUnit.Joule: + return FromJoules(value.Value); + case EnergyUnit.Kilocalorie: + return FromKilocalories(value.Value); + case EnergyUnit.Kilojoule: + return FromKilojoules(value.Value); + case EnergyUnit.KilowattHour: + return FromKilowattHours(value.Value); + case EnergyUnit.Megajoule: + return FromMegajoules(value.Value); + case EnergyUnit.MegawattHour: + return FromMegawattHours(value.Value); + case EnergyUnit.WattHour: + return FromWattHours(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -687,14 +733,14 @@ public double As(EnergyUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Energy Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs index 43dcf3cdee..de2645703b 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs @@ -279,6 +279,38 @@ public static Flow From(double value, FlowUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Flow unit value. + public static Flow? From(double? value, FlowUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case FlowUnit.CubicFootPerSecond: + return FromCubicFeetPerSecond(value.Value); + case FlowUnit.CubicMeterPerHour: + return FromCubicMetersPerHour(value.Value); + case FlowUnit.CubicMeterPerSecond: + return FromCubicMetersPerSecond(value.Value); + case FlowUnit.LitersPerMinute: + return FromLitersPerMinute(value.Value); + case FlowUnit.MillionUsGallonsPerDay: + return FromMillionUsGallonsPerDay(value.Value); + case FlowUnit.UsGallonsPerMinute: + return FromUsGallonsPerMinute(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -442,14 +474,14 @@ public double As(FlowUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Flow Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs index 31906db791..db2c0347fb 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs @@ -345,6 +345,42 @@ public static Force From(double value, ForceUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Force unit value. + public static Force? From(double? value, ForceUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case ForceUnit.Dyn: + return FromDyne(value.Value); + case ForceUnit.KilogramForce: + return FromKilogramsForce(value.Value); + case ForceUnit.Kilonewton: + return FromKilonewtons(value.Value); + case ForceUnit.KiloPond: + return FromKiloPonds(value.Value); + case ForceUnit.Newton: + return FromNewtons(value.Value); + case ForceUnit.Poundal: + return FromPoundals(value.Value); + case ForceUnit.PoundForce: + return FromPoundsForce(value.Value); + case ForceUnit.TonneForce: + return FromTonnesForce(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -512,14 +548,14 @@ public double As(ForceUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Force Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs index a2c202822e..e0f399e4dc 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs @@ -114,6 +114,28 @@ public static ForceChangeRate From(double value, ForceChangeRateUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// ForceChangeRate unit value. + public static ForceChangeRate? From(double? value, ForceChangeRateUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case ForceChangeRateUnit.NewtonPerSecond: + return FromNewtonsPerSecond(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -267,14 +289,14 @@ public double As(ForceChangeRateUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static ForceChangeRate Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs index 76b507d3b4..f3d0cc72b9 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs @@ -345,6 +345,42 @@ public static Frequency From(double value, FrequencyUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Frequency unit value. + public static Frequency? From(double? value, FrequencyUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case FrequencyUnit.CyclePerHour: + return FromCyclesPerHour(value.Value); + case FrequencyUnit.CyclePerMinute: + return FromCyclesPerMinute(value.Value); + case FrequencyUnit.Gigahertz: + return FromGigahertz(value.Value); + case FrequencyUnit.Hertz: + return FromHertz(value.Value); + case FrequencyUnit.Kilohertz: + return FromKilohertz(value.Value); + case FrequencyUnit.Megahertz: + return FromMegahertz(value.Value); + case FrequencyUnit.RadianPerSecond: + return FromRadiansPerSecond(value.Value); + case FrequencyUnit.Terahertz: + return FromTerahertz(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -512,14 +548,14 @@ public double As(FrequencyUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Frequency Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs index 0c418c6f87..799ccd16c3 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs @@ -939,6 +939,78 @@ public static Information From(double value, InformationUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Information unit value. + public static Information? From(double? value, InformationUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case InformationUnit.Bit: + return FromBits(value.Value); + case InformationUnit.Byte: + return FromBytes(value.Value); + case InformationUnit.Exabit: + return FromExabits(value.Value); + case InformationUnit.Exabyte: + return FromExabytes(value.Value); + case InformationUnit.Exbibit: + return FromExbibits(value.Value); + case InformationUnit.Exbibyte: + return FromExbibytes(value.Value); + case InformationUnit.Gibibit: + return FromGibibits(value.Value); + case InformationUnit.Gibibyte: + return FromGibibytes(value.Value); + case InformationUnit.Gigabit: + return FromGigabits(value.Value); + case InformationUnit.Gigabyte: + return FromGigabytes(value.Value); + case InformationUnit.Kibibit: + return FromKibibits(value.Value); + case InformationUnit.Kibibyte: + return FromKibibytes(value.Value); + case InformationUnit.Kilobit: + return FromKilobits(value.Value); + case InformationUnit.Kilobyte: + return FromKilobytes(value.Value); + case InformationUnit.Mebibit: + return FromMebibits(value.Value); + case InformationUnit.Mebibyte: + return FromMebibytes(value.Value); + case InformationUnit.Megabit: + return FromMegabits(value.Value); + case InformationUnit.Megabyte: + return FromMegabytes(value.Value); + case InformationUnit.Pebibit: + return FromPebibits(value.Value); + case InformationUnit.Pebibyte: + return FromPebibytes(value.Value); + case InformationUnit.Petabit: + return FromPetabits(value.Value); + case InformationUnit.Petabyte: + return FromPetabytes(value.Value); + case InformationUnit.Tebibit: + return FromTebibits(value.Value); + case InformationUnit.Tebibyte: + return FromTebibytes(value.Value); + case InformationUnit.Terabit: + return FromTerabits(value.Value); + case InformationUnit.Terabyte: + return FromTerabytes(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -1142,14 +1214,14 @@ public double As(InformationUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Information Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs b/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs index 2b669ca2e5..da97c9d6b8 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs @@ -345,6 +345,42 @@ public static KinematicViscosity From(double value, KinematicViscosityUnit fromU } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// KinematicViscosity unit value. + public static KinematicViscosity? From(double? value, KinematicViscosityUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case KinematicViscosityUnit.Centistokes: + return FromCentistokes(value.Value); + case KinematicViscosityUnit.Decistokes: + return FromDecistokes(value.Value); + case KinematicViscosityUnit.Kilostokes: + return FromKilostokes(value.Value); + case KinematicViscosityUnit.Microstokes: + return FromMicrostokes(value.Value); + case KinematicViscosityUnit.Millistokes: + return FromMillistokes(value.Value); + case KinematicViscosityUnit.Nanostokes: + return FromNanostokes(value.Value); + case KinematicViscosityUnit.SquareMeterPerSecond: + return FromSquareMetersPerSecond(value.Value); + case KinematicViscosityUnit.Stokes: + return FromStokes(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -512,14 +548,14 @@ public double As(KinematicViscosityUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static KinematicViscosity Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs index b4e247760c..5dfedcd27f 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs @@ -543,6 +543,54 @@ public static Length From(double value, LengthUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Length unit value. + public static Length? From(double? value, LengthUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case LengthUnit.Centimeter: + return FromCentimeters(value.Value); + case LengthUnit.Decimeter: + return FromDecimeters(value.Value); + case LengthUnit.Foot: + return FromFeet(value.Value); + case LengthUnit.Inch: + return FromInches(value.Value); + case LengthUnit.Kilometer: + return FromKilometers(value.Value); + case LengthUnit.Meter: + return FromMeters(value.Value); + case LengthUnit.Microinch: + return FromMicroinches(value.Value); + case LengthUnit.Micrometer: + return FromMicrometers(value.Value); + case LengthUnit.Mil: + return FromMils(value.Value); + case LengthUnit.Mile: + return FromMiles(value.Value); + case LengthUnit.Millimeter: + return FromMillimeters(value.Value); + case LengthUnit.Nanometer: + return FromNanometers(value.Value); + case LengthUnit.NauticalMile: + return FromNauticalMiles(value.Value); + case LengthUnit.Yard: + return FromYards(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -722,14 +770,14 @@ public double As(LengthUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Length Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs index cc1deb4fd0..9f12044eca 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs @@ -147,6 +147,30 @@ public static Level From(double value, LevelUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Level unit value. + public static Level? From(double? value, LevelUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case LevelUnit.Decibel: + return FromDecibels(value.Value); + case LevelUnit.Neper: + return FromNepers(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -310,14 +334,14 @@ public double As(LevelUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Level Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs index 16faf9931c..9debfacf2f 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs @@ -642,6 +642,60 @@ public static Mass From(double value, MassUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Mass unit value. + public static Mass? From(double? value, MassUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case MassUnit.Centigram: + return FromCentigrams(value.Value); + case MassUnit.Decagram: + return FromDecagrams(value.Value); + case MassUnit.Decigram: + return FromDecigrams(value.Value); + case MassUnit.Gram: + return FromGrams(value.Value); + case MassUnit.Hectogram: + return FromHectograms(value.Value); + case MassUnit.Kilogram: + return FromKilograms(value.Value); + case MassUnit.Kilotonne: + return FromKilotonnes(value.Value); + case MassUnit.LongTon: + return FromLongTons(value.Value); + case MassUnit.Megatonne: + return FromMegatonnes(value.Value); + case MassUnit.Microgram: + return FromMicrograms(value.Value); + case MassUnit.Milligram: + return FromMilligrams(value.Value); + case MassUnit.Nanogram: + return FromNanograms(value.Value); + case MassUnit.Ounce: + return FromOunces(value.Value); + case MassUnit.Pound: + return FromPounds(value.Value); + case MassUnit.ShortTon: + return FromShortTons(value.Value); + case MassUnit.Stone: + return FromStone(value.Value); + case MassUnit.Tonne: + return FromTonnes(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -827,14 +881,14 @@ public double As(MassUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Mass Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs index 7b1bd733b9..9f8bbc4f32 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs @@ -411,6 +411,46 @@ public static MassFlow From(double value, MassFlowUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// MassFlow unit value. + public static MassFlow? From(double? value, MassFlowUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case MassFlowUnit.CentigramPerSecond: + return FromCentigramsPerSecond(value.Value); + case MassFlowUnit.DecagramPerSecond: + return FromDecagramsPerSecond(value.Value); + case MassFlowUnit.DecigramPerSecond: + return FromDecigramsPerSecond(value.Value); + case MassFlowUnit.GramPerSecond: + return FromGramsPerSecond(value.Value); + case MassFlowUnit.HectogramPerSecond: + return FromHectogramsPerSecond(value.Value); + case MassFlowUnit.KilogramPerSecond: + return FromKilogramsPerSecond(value.Value); + case MassFlowUnit.MicrogramPerSecond: + return FromMicrogramsPerSecond(value.Value); + case MassFlowUnit.MilligramPerSecond: + return FromMilligramsPerSecond(value.Value); + case MassFlowUnit.NanogramPerSecond: + return FromNanogramsPerSecond(value.Value); + case MassFlowUnit.TonnePerDay: + return FromTonnesPerDay(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -582,14 +622,14 @@ public double As(MassFlowUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static MassFlow Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs index b7d0495e48..bb204b4604 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs @@ -609,6 +609,58 @@ public static Power From(double value, PowerUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Power unit value. + public static Power? From(double? value, PowerUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case PowerUnit.BoilerHorsepower: + return FromBoilerHorsepower(value.Value); + case PowerUnit.ElectricalHorsepower: + return FromElectricalHorsepower(value.Value); + case PowerUnit.Femtowatt: + return FromFemtowatts(value.Value); + case PowerUnit.Gigawatt: + return FromGigawatts(value.Value); + case PowerUnit.HydraulicHorsepower: + return FromHydraulicHorsepower(value.Value); + case PowerUnit.Kilowatt: + return FromKilowatts(value.Value); + case PowerUnit.MechanicalHorsepower: + return FromMechanicalHorsepower(value.Value); + case PowerUnit.Megawatt: + return FromMegawatts(value.Value); + case PowerUnit.MetricHorsepower: + return FromMetricHorsepower(value.Value); + case PowerUnit.Microwatt: + return FromMicrowatts(value.Value); + case PowerUnit.Milliwatt: + return FromMilliwatts(value.Value); + case PowerUnit.Nanowatt: + return FromNanowatts(value.Value); + case PowerUnit.Petawatt: + return FromPetawatts(value.Value); + case PowerUnit.Picowatt: + return FromPicowatts(value.Value); + case PowerUnit.Terawatt: + return FromTerawatts(value.Value); + case PowerUnit.Watt: + return FromWatts(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -792,14 +844,14 @@ public double As(PowerUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Power Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs index 93239028f3..220997b94e 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs @@ -147,6 +147,30 @@ public static PowerRatio From(double value, PowerRatioUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// PowerRatio unit value. + public static PowerRatio? From(double? value, PowerRatioUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case PowerRatioUnit.DecibelMilliwatt: + return FromDecibelMilliwatts(value.Value); + case PowerRatioUnit.DecibelWatt: + return FromDecibelWatts(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -310,14 +334,14 @@ public double As(PowerRatioUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static PowerRatio Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs index fc2d63d3f0..f9747f3a49 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs @@ -1170,6 +1170,92 @@ public static Pressure From(double value, PressureUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Pressure unit value. + public static Pressure? From(double? value, PressureUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case PressureUnit.Atmosphere: + return FromAtmospheres(value.Value); + case PressureUnit.Bar: + return FromBars(value.Value); + case PressureUnit.Centibar: + return FromCentibars(value.Value); + case PressureUnit.Decapascal: + return FromDecapascals(value.Value); + case PressureUnit.Decibar: + return FromDecibars(value.Value); + case PressureUnit.Gigapascal: + return FromGigapascals(value.Value); + case PressureUnit.Hectopascal: + return FromHectopascals(value.Value); + case PressureUnit.Kilobar: + return FromKilobars(value.Value); + case PressureUnit.KilogramForcePerSquareCentimeter: + return FromKilogramsForcePerSquareCentimeter(value.Value); + case PressureUnit.KilogramForcePerSquareMeter: + return FromKilogramsForcePerSquareMeter(value.Value); + case PressureUnit.KilogramForcePerSquareMillimeter: + return FromKilogramsForcePerSquareMillimeter(value.Value); + case PressureUnit.KilonewtonPerSquareCentimeter: + return FromKilonewtonsPerSquareCentimeter(value.Value); + case PressureUnit.KilonewtonPerSquareMeter: + return FromKilonewtonsPerSquareMeter(value.Value); + case PressureUnit.KilonewtonPerSquareMillimeter: + return FromKilonewtonsPerSquareMillimeter(value.Value); + case PressureUnit.Kilopascal: + return FromKilopascals(value.Value); + case PressureUnit.KilopoundForcePerSquareFoot: + return FromKilopoundsForcePerSquareFoot(value.Value); + case PressureUnit.KilopoundForcePerSquareInch: + return FromKilopoundsForcePerSquareInch(value.Value); + case PressureUnit.Megabar: + return FromMegabars(value.Value); + case PressureUnit.Megapascal: + return FromMegapascals(value.Value); + case PressureUnit.Micropascal: + return FromMicropascals(value.Value); + case PressureUnit.Millibar: + return FromMillibars(value.Value); + case PressureUnit.NewtonPerSquareCentimeter: + return FromNewtonsPerSquareCentimeter(value.Value); + case PressureUnit.NewtonPerSquareMeter: + return FromNewtonsPerSquareMeter(value.Value); + case PressureUnit.NewtonPerSquareMillimeter: + return FromNewtonsPerSquareMillimeter(value.Value); + case PressureUnit.Pascal: + return FromPascals(value.Value); + case PressureUnit.PoundForcePerSquareFoot: + return FromPoundsForcePerSquareFoot(value.Value); + case PressureUnit.PoundForcePerSquareInch: + return FromPoundsForcePerSquareInch(value.Value); + case PressureUnit.Psi: + return FromPsi(value.Value); + case PressureUnit.TechnicalAtmosphere: + return FromTechnicalAtmospheres(value.Value); + case PressureUnit.TonneForcePerSquareCentimeter: + return FromTonnesForcePerSquareCentimeter(value.Value); + case PressureUnit.TonneForcePerSquareMeter: + return FromTonnesForcePerSquareMeter(value.Value); + case PressureUnit.TonneForcePerSquareMillimeter: + return FromTonnesForcePerSquareMillimeter(value.Value); + case PressureUnit.Torr: + return FromTorrs(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -1387,14 +1473,14 @@ public double As(PressureUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Pressure Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs index 2c23d4bc20..8b41d3c16c 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs @@ -213,6 +213,34 @@ public static PressureChangeRate From(double value, PressureChangeRateUnit fromU } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// PressureChangeRate unit value. + public static PressureChangeRate? From(double? value, PressureChangeRateUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case PressureChangeRateUnit.AtmospherePerSecond: + return FromAtmospheresPerSecond(value.Value); + case PressureChangeRateUnit.KilopascalPerSecond: + return FromKilopascalsPerSecond(value.Value); + case PressureChangeRateUnit.MegapascalPerSecond: + return FromMegapascalsPerSecond(value.Value); + case PressureChangeRateUnit.PascalPerSecond: + return FromPascalsPerSecond(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -372,14 +400,14 @@ public double As(PressureChangeRateUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static PressureChangeRate Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs index 813fc58026..3777b2a580 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs @@ -279,6 +279,38 @@ public static Ratio From(double value, RatioUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Ratio unit value. + public static Ratio? From(double? value, RatioUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case RatioUnit.DecimalFraction: + return FromDecimalFractions(value.Value); + case RatioUnit.PartPerBillion: + return FromPartsPerBillion(value.Value); + case RatioUnit.PartPerMillion: + return FromPartsPerMillion(value.Value); + case RatioUnit.PartPerThousand: + return FromPartsPerThousand(value.Value); + case RatioUnit.PartPerTrillion: + return FromPartsPerTrillion(value.Value); + case RatioUnit.Percent: + return FromPercent(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -442,14 +474,14 @@ public double As(RatioUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Ratio Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs index b4b497b459..3a43f04e9a 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs @@ -345,6 +345,42 @@ public static RotationalSpeed From(double value, RotationalSpeedUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// RotationalSpeed unit value. + public static RotationalSpeed? From(double? value, RotationalSpeedUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case RotationalSpeedUnit.CentiradianPerSecond: + return FromCentiradiansPerSecond(value.Value); + case RotationalSpeedUnit.DeciradianPerSecond: + return FromDeciradiansPerSecond(value.Value); + case RotationalSpeedUnit.MicroradianPerSecond: + return FromMicroradiansPerSecond(value.Value); + case RotationalSpeedUnit.MilliradianPerSecond: + return FromMilliradiansPerSecond(value.Value); + case RotationalSpeedUnit.NanoradianPerSecond: + return FromNanoradiansPerSecond(value.Value); + case RotationalSpeedUnit.RadianPerSecond: + return FromRadiansPerSecond(value.Value); + case RotationalSpeedUnit.RevolutionPerMinute: + return FromRevolutionsPerMinute(value.Value); + case RotationalSpeedUnit.RevolutionPerSecond: + return FromRevolutionsPerSecond(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -512,14 +548,14 @@ public double As(RotationalSpeedUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static RotationalSpeed Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs index 8b3dec2eb0..4e0fc03144 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs @@ -345,6 +345,42 @@ public static SpecificEnergy From(double value, SpecificEnergyUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// SpecificEnergy unit value. + public static SpecificEnergy? From(double? value, SpecificEnergyUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case SpecificEnergyUnit.CaloriePerGram: + return FromCaloriesPerGram(value.Value); + case SpecificEnergyUnit.JoulePerKilogram: + return FromJoulesPerKilogram(value.Value); + case SpecificEnergyUnit.KilocaloriePerGram: + return FromKilocaloriesPerGram(value.Value); + case SpecificEnergyUnit.KilojoulePerKilogram: + return FromKilojoulesPerKilogram(value.Value); + case SpecificEnergyUnit.KilowattHourPerKilogram: + return FromKilowattHoursPerKilogram(value.Value); + case SpecificEnergyUnit.MegajoulePerKilogram: + return FromMegajoulesPerKilogram(value.Value); + case SpecificEnergyUnit.MegawattHourPerKilogram: + return FromMegawattHoursPerKilogram(value.Value); + case SpecificEnergyUnit.WattHourPerKilogram: + return FromWattHoursPerKilogram(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -512,14 +548,14 @@ public double As(SpecificEnergyUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static SpecificEnergy Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs index eab4cbab8c..2725595321 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs @@ -609,6 +609,58 @@ public static SpecificWeight From(double value, SpecificWeightUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// SpecificWeight unit value. + public static SpecificWeight? From(double? value, SpecificWeightUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case SpecificWeightUnit.KilogramForcePerCubicCentimeter: + return FromKilogramsForcePerCubicCentimeter(value.Value); + case SpecificWeightUnit.KilogramForcePerCubicMeter: + return FromKilogramsForcePerCubicMeter(value.Value); + case SpecificWeightUnit.KilogramForcePerCubicMillimeter: + return FromKilogramsForcePerCubicMillimeter(value.Value); + case SpecificWeightUnit.KilonewtonPerCubicCentimeter: + return FromKilonewtonsPerCubicCentimeter(value.Value); + case SpecificWeightUnit.KilonewtonPerCubicMeter: + return FromKilonewtonsPerCubicMeter(value.Value); + case SpecificWeightUnit.KilonewtonPerCubicMillimeter: + return FromKilonewtonsPerCubicMillimeter(value.Value); + case SpecificWeightUnit.KilopoundForcePerCubicFoot: + return FromKilopoundsForcePerCubicFoot(value.Value); + case SpecificWeightUnit.KilopoundForcePerCubicInch: + return FromKilopoundsForcePerCubicInch(value.Value); + case SpecificWeightUnit.NewtonPerCubicCentimeter: + return FromNewtonsPerCubicCentimeter(value.Value); + case SpecificWeightUnit.NewtonPerCubicMeter: + return FromNewtonsPerCubicMeter(value.Value); + case SpecificWeightUnit.NewtonPerCubicMillimeter: + return FromNewtonsPerCubicMillimeter(value.Value); + case SpecificWeightUnit.PoundForcePerCubicFoot: + return FromPoundsForcePerCubicFoot(value.Value); + case SpecificWeightUnit.PoundForcePerCubicInch: + return FromPoundsForcePerCubicInch(value.Value); + case SpecificWeightUnit.TonneForcePerCubicCentimeter: + return FromTonnesForcePerCubicCentimeter(value.Value); + case SpecificWeightUnit.TonneForcePerCubicMeter: + return FromTonnesForcePerCubicMeter(value.Value); + case SpecificWeightUnit.TonneForcePerCubicMillimeter: + return FromTonnesForcePerCubicMillimeter(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -792,14 +844,14 @@ public double As(SpecificWeightUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static SpecificWeight Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs index 08de3dcff0..f1acd36104 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs @@ -477,6 +477,50 @@ public static Speed From(double value, SpeedUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Speed unit value. + public static Speed? From(double? value, SpeedUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case SpeedUnit.CentimeterPerSecond: + return FromCentimetersPerSecond(value.Value); + case SpeedUnit.DecimeterPerSecond: + return FromDecimetersPerSecond(value.Value); + case SpeedUnit.FootPerSecond: + return FromFeetPerSecond(value.Value); + case SpeedUnit.KilometerPerHour: + return FromKilometersPerHour(value.Value); + case SpeedUnit.KilometerPerSecond: + return FromKilometersPerSecond(value.Value); + case SpeedUnit.Knot: + return FromKnots(value.Value); + case SpeedUnit.MeterPerHour: + return FromMetersPerHour(value.Value); + case SpeedUnit.MeterPerSecond: + return FromMetersPerSecond(value.Value); + case SpeedUnit.MicrometerPerSecond: + return FromMicrometersPerSecond(value.Value); + case SpeedUnit.MilePerHour: + return FromMilesPerHour(value.Value); + case SpeedUnit.MillimeterPerSecond: + return FromMillimetersPerSecond(value.Value); + case SpeedUnit.NanometerPerSecond: + return FromNanometersPerSecond(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -652,14 +696,14 @@ public double As(SpeedUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Speed Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs index f9b49346a9..9d5bb82150 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs @@ -345,6 +345,42 @@ public static Temperature From(double value, TemperatureUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Temperature unit value. + public static Temperature? From(double? value, TemperatureUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case TemperatureUnit.DegreeCelsius: + return FromDegreesCelsius(value.Value); + case TemperatureUnit.DegreeDelisle: + return FromDegreesDelisle(value.Value); + case TemperatureUnit.DegreeFahrenheit: + return FromDegreesFahrenheit(value.Value); + case TemperatureUnit.DegreeNewton: + return FromDegreesNewton(value.Value); + case TemperatureUnit.DegreeRankine: + return FromDegreesRankine(value.Value); + case TemperatureUnit.DegreeReaumur: + return FromDegreesReaumur(value.Value); + case TemperatureUnit.DegreeRoemer: + return FromDegreesRoemer(value.Value); + case TemperatureUnit.Kelvin: + return FromKelvins(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -512,14 +548,14 @@ public double As(TemperatureUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Temperature Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs index 5e8a4bb71f..a90f6bdea1 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs @@ -378,6 +378,44 @@ public static TemperatureChangeRate From(double value, TemperatureChangeRateUnit } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// TemperatureChangeRate unit value. + public static TemperatureChangeRate? From(double? value, TemperatureChangeRateUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond: + return FromCentidegreesCelsiusPerSecond(value.Value); + case TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond: + return FromDecadegreesCelsiusPerSecond(value.Value); + case TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond: + return FromDecidegreesCelsiusPerSecond(value.Value); + case TemperatureChangeRateUnit.DegreeCelsiusPerSecond: + return FromDegreesCelsiusPerSecond(value.Value); + case TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond: + return FromHectodegreesCelsiusPerSecond(value.Value); + case TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond: + return FromKilodegreesCelsiusPerSecond(value.Value); + case TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond: + return FromMicrodegreesCelsiusPerSecond(value.Value); + case TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond: + return FromMillidegreesCelsiusPerSecond(value.Value); + case TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond: + return FromNanodegreesCelsiusPerSecond(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -547,14 +585,14 @@ public double As(TemperatureChangeRateUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static TemperatureChangeRate Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs index 954b77ef13..f5c48a2363 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs @@ -609,6 +609,58 @@ public static Torque From(double value, TorqueUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Torque unit value. + public static Torque? From(double? value, TorqueUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case TorqueUnit.KilogramForceCentimeter: + return FromKilogramForceCentimeters(value.Value); + case TorqueUnit.KilogramForceMeter: + return FromKilogramForceMeters(value.Value); + case TorqueUnit.KilogramForceMillimeter: + return FromKilogramForceMillimeters(value.Value); + case TorqueUnit.KilonewtonCentimeter: + return FromKilonewtonCentimeters(value.Value); + case TorqueUnit.KilonewtonMeter: + return FromKilonewtonMeters(value.Value); + case TorqueUnit.KilonewtonMillimeter: + return FromKilonewtonMillimeters(value.Value); + case TorqueUnit.KilopoundForceFoot: + return FromKilopoundForceFeet(value.Value); + case TorqueUnit.KilopoundForceInch: + return FromKilopoundForceInches(value.Value); + case TorqueUnit.NewtonCentimeter: + return FromNewtonCentimeters(value.Value); + case TorqueUnit.NewtonMeter: + return FromNewtonMeters(value.Value); + case TorqueUnit.NewtonMillimeter: + return FromNewtonMillimeters(value.Value); + case TorqueUnit.PoundForceFoot: + return FromPoundForceFeet(value.Value); + case TorqueUnit.PoundForceInch: + return FromPoundForceInches(value.Value); + case TorqueUnit.TonneForceCentimeter: + return FromTonneForceCentimeters(value.Value); + case TorqueUnit.TonneForceMeter: + return FromTonneForceMeters(value.Value); + case TorqueUnit.TonneForceMillimeter: + return FromTonneForceMillimeters(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -792,14 +844,14 @@ public double As(TorqueUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Torque Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs b/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs index 2f844c5d9b..85819dba79 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs @@ -114,6 +114,28 @@ public static VitaminA From(double value, VitaminAUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// VitaminA unit value. + public static VitaminA? From(double? value, VitaminAUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case VitaminAUnit.InternationalUnit: + return FromInternationalUnits(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -267,14 +289,14 @@ public double As(VitaminAUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static VitaminA Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs index 7992b3ace3..2cd174d349 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs @@ -1040,6 +1040,84 @@ public static Volume From(double value, VolumeUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Volume unit value. + public static Volume? From(double? value, VolumeUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case VolumeUnit.AuTablespoon: + return FromAuTablespoons(value.Value); + case VolumeUnit.Centiliter: + return FromCentiliters(value.Value); + case VolumeUnit.CubicCentimeter: + return FromCubicCentimeters(value.Value); + case VolumeUnit.CubicDecimeter: + return FromCubicDecimeters(value.Value); + case VolumeUnit.CubicFoot: + return FromCubicFeet(value.Value); + case VolumeUnit.CubicInch: + return FromCubicInches(value.Value); + case VolumeUnit.CubicKilometer: + return FromCubicKilometers(value.Value); + case VolumeUnit.CubicMeter: + return FromCubicMeters(value.Value); + case VolumeUnit.CubicMicrometer: + return FromCubicMicrometers(value.Value); + case VolumeUnit.CubicMile: + return FromCubicMiles(value.Value); + case VolumeUnit.CubicMillimeter: + return FromCubicMillimeters(value.Value); + case VolumeUnit.CubicYard: + return FromCubicYards(value.Value); + case VolumeUnit.Deciliter: + return FromDeciliters(value.Value); + case VolumeUnit.Hectoliter: + return FromHectoliters(value.Value); + case VolumeUnit.ImperialGallon: + return FromImperialGallons(value.Value); + case VolumeUnit.ImperialOunce: + return FromImperialOunces(value.Value); + case VolumeUnit.Liter: + return FromLiters(value.Value); + case VolumeUnit.MetricCup: + return FromMetricCups(value.Value); + case VolumeUnit.MetricTeaspoon: + return FromMetricTeaspoons(value.Value); + case VolumeUnit.Milliliter: + return FromMilliliters(value.Value); + case VolumeUnit.Tablespoon: + return FromTablespoons(value.Value); + case VolumeUnit.Teaspoon: + return FromTeaspoons(value.Value); + case VolumeUnit.UkTablespoon: + return FromUkTablespoons(value.Value); + case VolumeUnit.UsCustomaryCup: + return FromUsCustomaryCups(value.Value); + case VolumeUnit.UsGallon: + return FromUsGallons(value.Value); + case VolumeUnit.UsLegalCup: + return FromUsLegalCups(value.Value); + case VolumeUnit.UsOunce: + return FromUsOunces(value.Value); + case VolumeUnit.UsTablespoon: + return FromUsTablespoons(value.Value); + case VolumeUnit.UsTeaspoon: + return FromUsTeaspoons(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -1249,14 +1327,14 @@ public double As(VolumeUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static Volume Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 index c7a161ad83..cff747a046 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 @@ -149,6 +149,30 @@ namespace UnitsNet } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// $className unit value. + public static $($className)? From(double? value, $unitEnumName fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { +"@; foreach ($unit in $units) {@" + case $unitEnumName.$($unit.SingularName): + return From$($unit.PluralName)(value.Value); +"@; }@" + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -312,14 +336,14 @@ namespace UnitsNet /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static $className Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 index f86381df40..20e6f86ac9 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 @@ -202,6 +202,21 @@ namespace UnitsNet.Tests Assert.IsTrue($baseUnitVariableName.Equals(null)); } + [Test] + public void StaticConstructorWithNullAndEnumReturnsNull() + { + $($className)? $baseUnitVariableName = $className.From(null,$($unitEnumName).$($baseUnit.SingularName)); + Assert.IsTrue($baseUnitVariableName.Equals(null)); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() + { + double? value = 1.0; + $($className)? $baseUnitVariableName = $className.From(value,$($unitEnumName).$($baseUnit.SingularName)); + Assert.IsTrue($($baseUnitVariableName).HasValue); + } + [Test] public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() { From 31f633509a2108764dad40e880296325311cb2c4 Mon Sep 17 00:00:00 2001 From: Erik Ovegard Date: Mon, 29 Feb 2016 09:23:19 +0100 Subject: [PATCH 3/5] Now calls "base" function instead of using constants when creating values from nullable doubles --- .../UnitClasses/Acceleration.g.cs | 14 ++-- .../UnitClasses/AmplitudeRatio.g.cs | 6 +- UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs | 20 +++--- UnitsNet/GeneratedCode/UnitClasses/Area.g.cs | 20 +++--- .../GeneratedCode/UnitClasses/Density.g.cs | 20 +++--- .../GeneratedCode/UnitClasses/Duration.g.cs | 20 +++--- .../UnitClasses/ElectricCurrent.g.cs | 12 ++-- .../UnitClasses/ElectricPotential.g.cs | 10 +-- .../UnitClasses/ElectricResistance.g.cs | 6 +- .../GeneratedCode/UnitClasses/Energy.g.cs | 26 ++++---- UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs | 12 ++-- UnitsNet/GeneratedCode/UnitClasses/Force.g.cs | 16 ++--- .../UnitClasses/ForceChangeRate.g.cs | 2 +- .../GeneratedCode/UnitClasses/Frequency.g.cs | 16 ++--- .../UnitClasses/Information.g.cs | 52 +++++++-------- .../UnitClasses/KinematicViscosity.g.cs | 16 ++--- .../GeneratedCode/UnitClasses/Length.g.cs | 28 ++++---- UnitsNet/GeneratedCode/UnitClasses/Level.g.cs | 4 +- UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs | 34 +++++----- .../GeneratedCode/UnitClasses/MassFlow.g.cs | 20 +++--- UnitsNet/GeneratedCode/UnitClasses/Power.g.cs | 32 ++++----- .../GeneratedCode/UnitClasses/PowerRatio.g.cs | 4 +- .../GeneratedCode/UnitClasses/Pressure.g.cs | 66 +++++++++---------- .../UnitClasses/PressureChangeRate.g.cs | 8 +-- UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs | 12 ++-- .../UnitClasses/RotationalSpeed.g.cs | 16 ++--- .../UnitClasses/SpecificEnergy.g.cs | 16 ++--- .../UnitClasses/SpecificWeight.g.cs | 32 ++++----- UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs | 24 +++---- .../UnitClasses/Temperature.g.cs | 16 ++--- .../UnitClasses/TemperatureChangeRate.g.cs | 18 ++--- .../GeneratedCode/UnitClasses/Torque.g.cs | 32 ++++----- .../GeneratedCode/UnitClasses/VitaminA.g.cs | 2 +- .../GeneratedCode/UnitClasses/Volume.g.cs | 58 ++++++++-------- .../Include-GenerateUnitClassSourceCode.ps1 | 2 +- 35 files changed, 346 insertions(+), 346 deletions(-) diff --git a/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs index fa02973607..2b8e7ac7b7 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs @@ -183,7 +183,7 @@ public static Acceleration FromNanometerPerSecondSquared(double nanometerperseco { if (centimeterpersecondsquared.HasValue) { - return new Acceleration((centimeterpersecondsquared.Value) * 1e-2d); + return FromCentimeterPerSecondSquared(centimeterpersecondsquared.Value); } else { @@ -198,7 +198,7 @@ public static Acceleration FromNanometerPerSecondSquared(double nanometerperseco { if (decimeterpersecondsquared.HasValue) { - return new Acceleration((decimeterpersecondsquared.Value) * 1e-1d); + return FromDecimeterPerSecondSquared(decimeterpersecondsquared.Value); } else { @@ -213,7 +213,7 @@ public static Acceleration FromNanometerPerSecondSquared(double nanometerperseco { if (kilometerpersecondsquared.HasValue) { - return new Acceleration((kilometerpersecondsquared.Value) * 1e3d); + return FromKilometerPerSecondSquared(kilometerpersecondsquared.Value); } else { @@ -228,7 +228,7 @@ public static Acceleration FromNanometerPerSecondSquared(double nanometerperseco { if (meterpersecondsquared.HasValue) { - return new Acceleration(meterpersecondsquared.Value); + return FromMeterPerSecondSquared(meterpersecondsquared.Value); } else { @@ -243,7 +243,7 @@ public static Acceleration FromNanometerPerSecondSquared(double nanometerperseco { if (micrometerpersecondsquared.HasValue) { - return new Acceleration((micrometerpersecondsquared.Value) * 1e-6d); + return FromMicrometerPerSecondSquared(micrometerpersecondsquared.Value); } else { @@ -258,7 +258,7 @@ public static Acceleration FromNanometerPerSecondSquared(double nanometerperseco { if (millimeterpersecondsquared.HasValue) { - return new Acceleration((millimeterpersecondsquared.Value) * 1e-3d); + return FromMillimeterPerSecondSquared(millimeterpersecondsquared.Value); } else { @@ -273,7 +273,7 @@ public static Acceleration FromNanometerPerSecondSquared(double nanometerperseco { if (nanometerpersecondsquared.HasValue) { - return new Acceleration((nanometerpersecondsquared.Value) * 1e-9d); + return FromNanometerPerSecondSquared(nanometerpersecondsquared.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs index cf7ad3dd0f..1c4f00cf33 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs @@ -119,7 +119,7 @@ public static AmplitudeRatio FromDecibelVolts(double decibelvolts) { if (decibelmicrovolts.HasValue) { - return new AmplitudeRatio(decibelmicrovolts.Value - 120); + return FromDecibelMicrovolts(decibelmicrovolts.Value); } else { @@ -134,7 +134,7 @@ public static AmplitudeRatio FromDecibelVolts(double decibelvolts) { if (decibelmillivolts.HasValue) { - return new AmplitudeRatio(decibelmillivolts.Value - 60); + return FromDecibelMillivolts(decibelmillivolts.Value); } else { @@ -149,7 +149,7 @@ public static AmplitudeRatio FromDecibelVolts(double decibelvolts) { if (decibelvolts.HasValue) { - return new AmplitudeRatio(decibelvolts.Value); + return FromDecibelVolts(decibelvolts.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs index 9be13e518d..3cd71600f9 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs @@ -231,7 +231,7 @@ public static Angle FromRadians(double radians) { if (arcminutes.HasValue) { - return new Angle(arcminutes.Value/60); + return FromArcminutes(arcminutes.Value); } else { @@ -246,7 +246,7 @@ public static Angle FromRadians(double radians) { if (arcseconds.HasValue) { - return new Angle(arcseconds.Value/3600); + return FromArcseconds(arcseconds.Value); } else { @@ -261,7 +261,7 @@ public static Angle FromRadians(double radians) { if (centiradians.HasValue) { - return new Angle((centiradians.Value*180/Math.PI) * 1e-2d); + return FromCentiradians(centiradians.Value); } else { @@ -276,7 +276,7 @@ public static Angle FromRadians(double radians) { if (deciradians.HasValue) { - return new Angle((deciradians.Value*180/Math.PI) * 1e-1d); + return FromDeciradians(deciradians.Value); } else { @@ -291,7 +291,7 @@ public static Angle FromRadians(double radians) { if (degrees.HasValue) { - return new Angle(degrees.Value); + return FromDegrees(degrees.Value); } else { @@ -306,7 +306,7 @@ public static Angle FromRadians(double radians) { if (gradians.HasValue) { - return new Angle(gradians.Value*0.9); + return FromGradians(gradians.Value); } else { @@ -321,7 +321,7 @@ public static Angle FromRadians(double radians) { if (microradians.HasValue) { - return new Angle((microradians.Value*180/Math.PI) * 1e-6d); + return FromMicroradians(microradians.Value); } else { @@ -336,7 +336,7 @@ public static Angle FromRadians(double radians) { if (milliradians.HasValue) { - return new Angle((milliradians.Value*180/Math.PI) * 1e-3d); + return FromMilliradians(milliradians.Value); } else { @@ -351,7 +351,7 @@ public static Angle FromRadians(double radians) { if (nanoradians.HasValue) { - return new Angle((nanoradians.Value*180/Math.PI) * 1e-9d); + return FromNanoradians(nanoradians.Value); } else { @@ -366,7 +366,7 @@ public static Angle FromRadians(double radians) { if (radians.HasValue) { - return new Angle(radians.Value*180/Math.PI); + return FromRadians(radians.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs index eef47ba75f..ceef566ce3 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs @@ -231,7 +231,7 @@ public static Area FromSquareYards(double squareyards) { if (squarecentimeters.HasValue) { - return new Area(squarecentimeters.Value*1e-4); + return FromSquareCentimeters(squarecentimeters.Value); } else { @@ -246,7 +246,7 @@ public static Area FromSquareYards(double squareyards) { if (squaredecimeters.HasValue) { - return new Area(squaredecimeters.Value*1e-2); + return FromSquareDecimeters(squaredecimeters.Value); } else { @@ -261,7 +261,7 @@ public static Area FromSquareYards(double squareyards) { if (squarefeet.HasValue) { - return new Area(squarefeet.Value*0.092903); + return FromSquareFeet(squarefeet.Value); } else { @@ -276,7 +276,7 @@ public static Area FromSquareYards(double squareyards) { if (squareinches.HasValue) { - return new Area(squareinches.Value*0.00064516); + return FromSquareInches(squareinches.Value); } else { @@ -291,7 +291,7 @@ public static Area FromSquareYards(double squareyards) { if (squarekilometers.HasValue) { - return new Area(squarekilometers.Value*1e6); + return FromSquareKilometers(squarekilometers.Value); } else { @@ -306,7 +306,7 @@ public static Area FromSquareYards(double squareyards) { if (squaremeters.HasValue) { - return new Area(squaremeters.Value); + return FromSquareMeters(squaremeters.Value); } else { @@ -321,7 +321,7 @@ public static Area FromSquareYards(double squareyards) { if (squaremicrometers.HasValue) { - return new Area(squaremicrometers.Value*1e-12); + return FromSquareMicrometers(squaremicrometers.Value); } else { @@ -336,7 +336,7 @@ public static Area FromSquareYards(double squareyards) { if (squaremiles.HasValue) { - return new Area(squaremiles.Value*2.59e6); + return FromSquareMiles(squaremiles.Value); } else { @@ -351,7 +351,7 @@ public static Area FromSquareYards(double squareyards) { if (squaremillimeters.HasValue) { - return new Area(squaremillimeters.Value*1e-6); + return FromSquareMillimeters(squaremillimeters.Value); } else { @@ -366,7 +366,7 @@ public static Area FromSquareYards(double squareyards) { if (squareyards.HasValue) { - return new Area(squareyards.Value*0.836127); + return FromSquareYards(squareyards.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs index 4a7559a051..63fe1504f5 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs @@ -231,7 +231,7 @@ public static Density FromTonnesPerCubicMillimeter(double tonnespercubicmillimet { if (kilogramspercubiccentimeter.HasValue) { - return new Density(kilogramspercubiccentimeter.Value*100000000); + return FromKilogramsPerCubicCentimeter(kilogramspercubiccentimeter.Value); } else { @@ -246,7 +246,7 @@ public static Density FromTonnesPerCubicMillimeter(double tonnespercubicmillimet { if (kilogramspercubicmeter.HasValue) { - return new Density(kilogramspercubicmeter.Value); + return FromKilogramsPerCubicMeter(kilogramspercubicmeter.Value); } else { @@ -261,7 +261,7 @@ public static Density FromTonnesPerCubicMillimeter(double tonnespercubicmillimet { if (kilogramspercubicmillimeter.HasValue) { - return new Density(kilogramspercubicmillimeter.Value*1000000000000); + return FromKilogramsPerCubicMillimeter(kilogramspercubicmillimeter.Value); } else { @@ -276,7 +276,7 @@ public static Density FromTonnesPerCubicMillimeter(double tonnespercubicmillimet { if (kilopoundspercubicfoot.HasValue) { - return new Density((kilopoundspercubicfoot.Value/0.062427961) * 1e3d); + return FromKilopoundsPerCubicFoot(kilopoundspercubicfoot.Value); } else { @@ -291,7 +291,7 @@ public static Density FromTonnesPerCubicMillimeter(double tonnespercubicmillimet { if (kilopoundspercubicinch.HasValue) { - return new Density((kilopoundspercubicinch.Value*27679.904710191) * 1e3d); + return FromKilopoundsPerCubicInch(kilopoundspercubicinch.Value); } else { @@ -306,7 +306,7 @@ public static Density FromTonnesPerCubicMillimeter(double tonnespercubicmillimet { if (poundspercubicfoot.HasValue) { - return new Density(poundspercubicfoot.Value/0.062427961); + return FromPoundsPerCubicFoot(poundspercubicfoot.Value); } else { @@ -321,7 +321,7 @@ public static Density FromTonnesPerCubicMillimeter(double tonnespercubicmillimet { if (poundspercubicinch.HasValue) { - return new Density(poundspercubicinch.Value*27679.904710191); + return FromPoundsPerCubicInch(poundspercubicinch.Value); } else { @@ -336,7 +336,7 @@ public static Density FromTonnesPerCubicMillimeter(double tonnespercubicmillimet { if (tonnespercubiccentimeter.HasValue) { - return new Density(tonnespercubiccentimeter.Value*100000000000); + return FromTonnesPerCubicCentimeter(tonnespercubiccentimeter.Value); } else { @@ -351,7 +351,7 @@ public static Density FromTonnesPerCubicMillimeter(double tonnespercubicmillimet { if (tonnespercubicmeter.HasValue) { - return new Density(tonnespercubicmeter.Value*1000); + return FromTonnesPerCubicMeter(tonnespercubicmeter.Value); } else { @@ -366,7 +366,7 @@ public static Density FromTonnesPerCubicMillimeter(double tonnespercubicmillimet { if (tonnespercubicmillimeter.HasValue) { - return new Density(tonnespercubicmillimeter.Value*1000000000000000); + return FromTonnesPerCubicMillimeter(tonnespercubicmillimeter.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs index 164b6479df..c61a489418 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs @@ -231,7 +231,7 @@ public static Duration FromYears(double years) { if (days.HasValue) { - return new Duration(days.Value*24*3600); + return FromDays(days.Value); } else { @@ -246,7 +246,7 @@ public static Duration FromYears(double years) { if (hours.HasValue) { - return new Duration(hours.Value*3600); + return FromHours(hours.Value); } else { @@ -261,7 +261,7 @@ public static Duration FromYears(double years) { if (microseconds.HasValue) { - return new Duration(microseconds.Value/1e6); + return FromMicroseconds(microseconds.Value); } else { @@ -276,7 +276,7 @@ public static Duration FromYears(double years) { if (milliseconds.HasValue) { - return new Duration(milliseconds.Value/1e3); + return FromMilliseconds(milliseconds.Value); } else { @@ -291,7 +291,7 @@ public static Duration FromYears(double years) { if (minutes.HasValue) { - return new Duration(minutes.Value*60); + return FromMinutes(minutes.Value); } else { @@ -306,7 +306,7 @@ public static Duration FromYears(double years) { if (months.HasValue) { - return new Duration(months.Value*30*24*3600); + return FromMonths(months.Value); } else { @@ -321,7 +321,7 @@ public static Duration FromYears(double years) { if (nanoseconds.HasValue) { - return new Duration(nanoseconds.Value/1e9); + return FromNanoseconds(nanoseconds.Value); } else { @@ -336,7 +336,7 @@ public static Duration FromYears(double years) { if (seconds.HasValue) { - return new Duration(seconds.Value); + return FromSeconds(seconds.Value); } else { @@ -351,7 +351,7 @@ public static Duration FromYears(double years) { if (weeks.HasValue) { - return new Duration(weeks.Value*7*24*3600); + return FromWeeks(weeks.Value); } else { @@ -366,7 +366,7 @@ public static Duration FromYears(double years) { if (years.HasValue) { - return new Duration(years.Value*365*24*3600); + return FromYears(years.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs index a541aefd59..57528f0206 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs @@ -167,7 +167,7 @@ public static ElectricCurrent FromNanoamperes(double nanoamperes) { if (amperes.HasValue) { - return new ElectricCurrent(amperes.Value); + return FromAmperes(amperes.Value); } else { @@ -182,7 +182,7 @@ public static ElectricCurrent FromNanoamperes(double nanoamperes) { if (kiloamperes.HasValue) { - return new ElectricCurrent((kiloamperes.Value) * 1e3d); + return FromKiloamperes(kiloamperes.Value); } else { @@ -197,7 +197,7 @@ public static ElectricCurrent FromNanoamperes(double nanoamperes) { if (megaamperes.HasValue) { - return new ElectricCurrent((megaamperes.Value) * 1e6d); + return FromMegaamperes(megaamperes.Value); } else { @@ -212,7 +212,7 @@ public static ElectricCurrent FromNanoamperes(double nanoamperes) { if (microamperes.HasValue) { - return new ElectricCurrent((microamperes.Value) * 1e-6d); + return FromMicroamperes(microamperes.Value); } else { @@ -227,7 +227,7 @@ public static ElectricCurrent FromNanoamperes(double nanoamperes) { if (milliamperes.HasValue) { - return new ElectricCurrent((milliamperes.Value) * 1e-3d); + return FromMilliamperes(milliamperes.Value); } else { @@ -242,7 +242,7 @@ public static ElectricCurrent FromNanoamperes(double nanoamperes) { if (nanoamperes.HasValue) { - return new ElectricCurrent((nanoamperes.Value) * 1e-9d); + return FromNanoamperes(nanoamperes.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs index 3aac6718db..5969775fa5 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs @@ -151,7 +151,7 @@ public static ElectricPotential FromVolts(double volts) { if (kilovolts.HasValue) { - return new ElectricPotential((kilovolts.Value) * 1e3d); + return FromKilovolts(kilovolts.Value); } else { @@ -166,7 +166,7 @@ public static ElectricPotential FromVolts(double volts) { if (megavolts.HasValue) { - return new ElectricPotential((megavolts.Value) * 1e6d); + return FromMegavolts(megavolts.Value); } else { @@ -181,7 +181,7 @@ public static ElectricPotential FromVolts(double volts) { if (microvolts.HasValue) { - return new ElectricPotential((microvolts.Value) * 1e-6d); + return FromMicrovolts(microvolts.Value); } else { @@ -196,7 +196,7 @@ public static ElectricPotential FromVolts(double volts) { if (millivolts.HasValue) { - return new ElectricPotential((millivolts.Value) * 1e-3d); + return FromMillivolts(millivolts.Value); } else { @@ -211,7 +211,7 @@ public static ElectricPotential FromVolts(double volts) { if (volts.HasValue) { - return new ElectricPotential(volts.Value); + return FromVolts(volts.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs index 57bdb4fcb1..812fac2ee6 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs @@ -119,7 +119,7 @@ public static ElectricResistance FromOhms(double ohms) { if (kiloohms.HasValue) { - return new ElectricResistance((kiloohms.Value) * 1e3d); + return FromKiloohms(kiloohms.Value); } else { @@ -134,7 +134,7 @@ public static ElectricResistance FromOhms(double ohms) { if (megaohms.HasValue) { - return new ElectricResistance((megaohms.Value) * 1e6d); + return FromMegaohms(megaohms.Value); } else { @@ -149,7 +149,7 @@ public static ElectricResistance FromOhms(double ohms) { if (ohms.HasValue) { - return new ElectricResistance(ohms.Value); + return FromOhms(ohms.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs index a3bade27df..85f2a9c87f 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs @@ -279,7 +279,7 @@ public static Energy FromWattHours(double watthours) { if (britishthermalunits.HasValue) { - return new Energy(britishthermalunits.Value*1055.05585262); + return FromBritishThermalUnits(britishthermalunits.Value); } else { @@ -294,7 +294,7 @@ public static Energy FromWattHours(double watthours) { if (calories.HasValue) { - return new Energy(calories.Value*4.184); + return FromCalories(calories.Value); } else { @@ -309,7 +309,7 @@ public static Energy FromWattHours(double watthours) { if (electronvolts.HasValue) { - return new Energy(electronvolts.Value*1.602176565e-19); + return FromElectronVolts(electronvolts.Value); } else { @@ -324,7 +324,7 @@ public static Energy FromWattHours(double watthours) { if (ergs.HasValue) { - return new Energy(ergs.Value*1e-7); + return FromErgs(ergs.Value); } else { @@ -339,7 +339,7 @@ public static Energy FromWattHours(double watthours) { if (footpounds.HasValue) { - return new Energy(footpounds.Value*1.355817948); + return FromFootPounds(footpounds.Value); } else { @@ -354,7 +354,7 @@ public static Energy FromWattHours(double watthours) { if (gigawatthours.HasValue) { - return new Energy((gigawatthours.Value*3600d) * 1e9d); + return FromGigawattHours(gigawatthours.Value); } else { @@ -369,7 +369,7 @@ public static Energy FromWattHours(double watthours) { if (joules.HasValue) { - return new Energy(joules.Value); + return FromJoules(joules.Value); } else { @@ -384,7 +384,7 @@ public static Energy FromWattHours(double watthours) { if (kilocalories.HasValue) { - return new Energy((kilocalories.Value*4.184) * 1e3d); + return FromKilocalories(kilocalories.Value); } else { @@ -399,7 +399,7 @@ public static Energy FromWattHours(double watthours) { if (kilojoules.HasValue) { - return new Energy((kilojoules.Value) * 1e3d); + return FromKilojoules(kilojoules.Value); } else { @@ -414,7 +414,7 @@ public static Energy FromWattHours(double watthours) { if (kilowatthours.HasValue) { - return new Energy((kilowatthours.Value*3600d) * 1e3d); + return FromKilowattHours(kilowatthours.Value); } else { @@ -429,7 +429,7 @@ public static Energy FromWattHours(double watthours) { if (megajoules.HasValue) { - return new Energy((megajoules.Value) * 1e6d); + return FromMegajoules(megajoules.Value); } else { @@ -444,7 +444,7 @@ public static Energy FromWattHours(double watthours) { if (megawatthours.HasValue) { - return new Energy((megawatthours.Value*3600d) * 1e6d); + return FromMegawattHours(megawatthours.Value); } else { @@ -459,7 +459,7 @@ public static Energy FromWattHours(double watthours) { if (watthours.HasValue) { - return new Energy(watthours.Value*3600d); + return FromWattHours(watthours.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs index de2645703b..be2d15704b 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs @@ -167,7 +167,7 @@ public static Flow FromUsGallonsPerMinute(double usgallonsperminute) { if (cubicfeetpersecond.HasValue) { - return new Flow(cubicfeetpersecond.Value/35.314666213); + return FromCubicFeetPerSecond(cubicfeetpersecond.Value); } else { @@ -182,7 +182,7 @@ public static Flow FromUsGallonsPerMinute(double usgallonsperminute) { if (cubicmetersperhour.HasValue) { - return new Flow(cubicmetersperhour.Value/3600); + return FromCubicMetersPerHour(cubicmetersperhour.Value); } else { @@ -197,7 +197,7 @@ public static Flow FromUsGallonsPerMinute(double usgallonsperminute) { if (cubicmeterspersecond.HasValue) { - return new Flow(cubicmeterspersecond.Value); + return FromCubicMetersPerSecond(cubicmeterspersecond.Value); } else { @@ -212,7 +212,7 @@ public static Flow FromUsGallonsPerMinute(double usgallonsperminute) { if (litersperminute.HasValue) { - return new Flow(litersperminute.Value/60000.00000); + return FromLitersPerMinute(litersperminute.Value); } else { @@ -227,7 +227,7 @@ public static Flow FromUsGallonsPerMinute(double usgallonsperminute) { if (millionusgallonsperday.HasValue) { - return new Flow(millionusgallonsperday.Value/22.824465227); + return FromMillionUsGallonsPerDay(millionusgallonsperday.Value); } else { @@ -242,7 +242,7 @@ public static Flow FromUsGallonsPerMinute(double usgallonsperminute) { if (usgallonsperminute.HasValue) { - return new Flow(usgallonsperminute.Value/15850.323141489); + return FromUsGallonsPerMinute(usgallonsperminute.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs index db2c0347fb..b9af6953be 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs @@ -199,7 +199,7 @@ public static Force FromTonnesForce(double tonnesforce) { if (dyne.HasValue) { - return new Force(dyne.Value/1e5); + return FromDyne(dyne.Value); } else { @@ -214,7 +214,7 @@ public static Force FromTonnesForce(double tonnesforce) { if (kilogramsforce.HasValue) { - return new Force(kilogramsforce.Value*Constants.Gravity); + return FromKilogramsForce(kilogramsforce.Value); } else { @@ -229,7 +229,7 @@ public static Force FromTonnesForce(double tonnesforce) { if (kilonewtons.HasValue) { - return new Force((kilonewtons.Value) * 1e3d); + return FromKilonewtons(kilonewtons.Value); } else { @@ -244,7 +244,7 @@ public static Force FromTonnesForce(double tonnesforce) { if (kiloponds.HasValue) { - return new Force(kiloponds.Value*Constants.Gravity); + return FromKiloPonds(kiloponds.Value); } else { @@ -259,7 +259,7 @@ public static Force FromTonnesForce(double tonnesforce) { if (newtons.HasValue) { - return new Force(newtons.Value); + return FromNewtons(newtons.Value); } else { @@ -274,7 +274,7 @@ public static Force FromTonnesForce(double tonnesforce) { if (poundals.HasValue) { - return new Force(poundals.Value*0.13825502798973041652092282466083); + return FromPoundals(poundals.Value); } else { @@ -289,7 +289,7 @@ public static Force FromTonnesForce(double tonnesforce) { if (poundsforce.HasValue) { - return new Force(poundsforce.Value*4.4482216152605095551842641431421); + return FromPoundsForce(poundsforce.Value); } else { @@ -304,7 +304,7 @@ public static Force FromTonnesForce(double tonnesforce) { if (tonnesforce.HasValue) { - return new Force(tonnesforce.Value*Constants.Gravity*1000); + return FromTonnesForce(tonnesforce.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs index e0f399e4dc..8c1adf8ef1 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs @@ -87,7 +87,7 @@ public static ForceChangeRate FromNewtonsPerSecond(double newtonspersecond) { if (newtonspersecond.HasValue) { - return new ForceChangeRate(newtonspersecond.Value); + return FromNewtonsPerSecond(newtonspersecond.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs index f3d0cc72b9..c72c7fbd88 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs @@ -199,7 +199,7 @@ public static Frequency FromTerahertz(double terahertz) { if (cyclesperhour.HasValue) { - return new Frequency(cyclesperhour.Value*3600); + return FromCyclesPerHour(cyclesperhour.Value); } else { @@ -214,7 +214,7 @@ public static Frequency FromTerahertz(double terahertz) { if (cyclesperminute.HasValue) { - return new Frequency(cyclesperminute.Value*60); + return FromCyclesPerMinute(cyclesperminute.Value); } else { @@ -229,7 +229,7 @@ public static Frequency FromTerahertz(double terahertz) { if (gigahertz.HasValue) { - return new Frequency((gigahertz.Value) * 1e9d); + return FromGigahertz(gigahertz.Value); } else { @@ -244,7 +244,7 @@ public static Frequency FromTerahertz(double terahertz) { if (hertz.HasValue) { - return new Frequency(hertz.Value); + return FromHertz(hertz.Value); } else { @@ -259,7 +259,7 @@ public static Frequency FromTerahertz(double terahertz) { if (kilohertz.HasValue) { - return new Frequency((kilohertz.Value) * 1e3d); + return FromKilohertz(kilohertz.Value); } else { @@ -274,7 +274,7 @@ public static Frequency FromTerahertz(double terahertz) { if (megahertz.HasValue) { - return new Frequency((megahertz.Value) * 1e6d); + return FromMegahertz(megahertz.Value); } else { @@ -289,7 +289,7 @@ public static Frequency FromTerahertz(double terahertz) { if (radianspersecond.HasValue) { - return new Frequency(radianspersecond.Value/6.2831853072); + return FromRadiansPerSecond(radianspersecond.Value); } else { @@ -304,7 +304,7 @@ public static Frequency FromTerahertz(double terahertz) { if (terahertz.HasValue) { - return new Frequency((terahertz.Value) * 1e12d); + return FromTerahertz(terahertz.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs index 799ccd16c3..b1226d22b2 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs @@ -487,7 +487,7 @@ public static Information FromTerabytes(double terabytes) { if (bits.HasValue) { - return new Information(Convert.ToDecimal(bits.Value)); + return FromBits(bits.Value); } else { @@ -502,7 +502,7 @@ public static Information FromTerabytes(double terabytes) { if (bytes.HasValue) { - return new Information(Convert.ToDecimal(bytes.Value*8d)); + return FromBytes(bytes.Value); } else { @@ -517,7 +517,7 @@ public static Information FromTerabytes(double terabytes) { if (exabits.HasValue) { - return new Information(Convert.ToDecimal((exabits.Value) * 1e18d)); + return FromExabits(exabits.Value); } else { @@ -532,7 +532,7 @@ public static Information FromTerabytes(double terabytes) { if (exabytes.HasValue) { - return new Information(Convert.ToDecimal((exabytes.Value*8d) * 1e18d)); + return FromExabytes(exabytes.Value); } else { @@ -547,7 +547,7 @@ public static Information FromTerabytes(double terabytes) { if (exbibits.HasValue) { - return new Information(Convert.ToDecimal((exbibits.Value) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024))); + return FromExbibits(exbibits.Value); } else { @@ -562,7 +562,7 @@ public static Information FromTerabytes(double terabytes) { if (exbibytes.HasValue) { - return new Information(Convert.ToDecimal((exbibytes.Value*8d) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024))); + return FromExbibytes(exbibytes.Value); } else { @@ -577,7 +577,7 @@ public static Information FromTerabytes(double terabytes) { if (gibibits.HasValue) { - return new Information(Convert.ToDecimal((gibibits.Value) * (1024d * 1024 * 1024))); + return FromGibibits(gibibits.Value); } else { @@ -592,7 +592,7 @@ public static Information FromTerabytes(double terabytes) { if (gibibytes.HasValue) { - return new Information(Convert.ToDecimal((gibibytes.Value*8d) * (1024d * 1024 * 1024))); + return FromGibibytes(gibibytes.Value); } else { @@ -607,7 +607,7 @@ public static Information FromTerabytes(double terabytes) { if (gigabits.HasValue) { - return new Information(Convert.ToDecimal((gigabits.Value) * 1e9d)); + return FromGigabits(gigabits.Value); } else { @@ -622,7 +622,7 @@ public static Information FromTerabytes(double terabytes) { if (gigabytes.HasValue) { - return new Information(Convert.ToDecimal((gigabytes.Value*8d) * 1e9d)); + return FromGigabytes(gigabytes.Value); } else { @@ -637,7 +637,7 @@ public static Information FromTerabytes(double terabytes) { if (kibibits.HasValue) { - return new Information(Convert.ToDecimal((kibibits.Value) * 1024d)); + return FromKibibits(kibibits.Value); } else { @@ -652,7 +652,7 @@ public static Information FromTerabytes(double terabytes) { if (kibibytes.HasValue) { - return new Information(Convert.ToDecimal((kibibytes.Value*8d) * 1024d)); + return FromKibibytes(kibibytes.Value); } else { @@ -667,7 +667,7 @@ public static Information FromTerabytes(double terabytes) { if (kilobits.HasValue) { - return new Information(Convert.ToDecimal((kilobits.Value) * 1e3d)); + return FromKilobits(kilobits.Value); } else { @@ -682,7 +682,7 @@ public static Information FromTerabytes(double terabytes) { if (kilobytes.HasValue) { - return new Information(Convert.ToDecimal((kilobytes.Value*8d) * 1e3d)); + return FromKilobytes(kilobytes.Value); } else { @@ -697,7 +697,7 @@ public static Information FromTerabytes(double terabytes) { if (mebibits.HasValue) { - return new Information(Convert.ToDecimal((mebibits.Value) * (1024d * 1024))); + return FromMebibits(mebibits.Value); } else { @@ -712,7 +712,7 @@ public static Information FromTerabytes(double terabytes) { if (mebibytes.HasValue) { - return new Information(Convert.ToDecimal((mebibytes.Value*8d) * (1024d * 1024))); + return FromMebibytes(mebibytes.Value); } else { @@ -727,7 +727,7 @@ public static Information FromTerabytes(double terabytes) { if (megabits.HasValue) { - return new Information(Convert.ToDecimal((megabits.Value) * 1e6d)); + return FromMegabits(megabits.Value); } else { @@ -742,7 +742,7 @@ public static Information FromTerabytes(double terabytes) { if (megabytes.HasValue) { - return new Information(Convert.ToDecimal((megabytes.Value*8d) * 1e6d)); + return FromMegabytes(megabytes.Value); } else { @@ -757,7 +757,7 @@ public static Information FromTerabytes(double terabytes) { if (pebibits.HasValue) { - return new Information(Convert.ToDecimal((pebibits.Value) * (1024d * 1024 * 1024 * 1024 * 1024))); + return FromPebibits(pebibits.Value); } else { @@ -772,7 +772,7 @@ public static Information FromTerabytes(double terabytes) { if (pebibytes.HasValue) { - return new Information(Convert.ToDecimal((pebibytes.Value*8d) * (1024d * 1024 * 1024 * 1024 * 1024))); + return FromPebibytes(pebibytes.Value); } else { @@ -787,7 +787,7 @@ public static Information FromTerabytes(double terabytes) { if (petabits.HasValue) { - return new Information(Convert.ToDecimal((petabits.Value) * 1e15d)); + return FromPetabits(petabits.Value); } else { @@ -802,7 +802,7 @@ public static Information FromTerabytes(double terabytes) { if (petabytes.HasValue) { - return new Information(Convert.ToDecimal((petabytes.Value*8d) * 1e15d)); + return FromPetabytes(petabytes.Value); } else { @@ -817,7 +817,7 @@ public static Information FromTerabytes(double terabytes) { if (tebibits.HasValue) { - return new Information(Convert.ToDecimal((tebibits.Value) * (1024d * 1024 * 1024 * 1024))); + return FromTebibits(tebibits.Value); } else { @@ -832,7 +832,7 @@ public static Information FromTerabytes(double terabytes) { if (tebibytes.HasValue) { - return new Information(Convert.ToDecimal((tebibytes.Value*8d) * (1024d * 1024 * 1024 * 1024))); + return FromTebibytes(tebibytes.Value); } else { @@ -847,7 +847,7 @@ public static Information FromTerabytes(double terabytes) { if (terabits.HasValue) { - return new Information(Convert.ToDecimal((terabits.Value) * 1e12d)); + return FromTerabits(terabits.Value); } else { @@ -862,7 +862,7 @@ public static Information FromTerabytes(double terabytes) { if (terabytes.HasValue) { - return new Information(Convert.ToDecimal((terabytes.Value*8d) * 1e12d)); + return FromTerabytes(terabytes.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs b/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs index da97c9d6b8..0655861156 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs @@ -199,7 +199,7 @@ public static KinematicViscosity FromStokes(double stokes) { if (centistokes.HasValue) { - return new KinematicViscosity((centistokes.Value/1e4) * 1e-2d); + return FromCentistokes(centistokes.Value); } else { @@ -214,7 +214,7 @@ public static KinematicViscosity FromStokes(double stokes) { if (decistokes.HasValue) { - return new KinematicViscosity((decistokes.Value/1e4) * 1e-1d); + return FromDecistokes(decistokes.Value); } else { @@ -229,7 +229,7 @@ public static KinematicViscosity FromStokes(double stokes) { if (kilostokes.HasValue) { - return new KinematicViscosity((kilostokes.Value/1e4) * 1e3d); + return FromKilostokes(kilostokes.Value); } else { @@ -244,7 +244,7 @@ public static KinematicViscosity FromStokes(double stokes) { if (microstokes.HasValue) { - return new KinematicViscosity((microstokes.Value/1e4) * 1e-6d); + return FromMicrostokes(microstokes.Value); } else { @@ -259,7 +259,7 @@ public static KinematicViscosity FromStokes(double stokes) { if (millistokes.HasValue) { - return new KinematicViscosity((millistokes.Value/1e4) * 1e-3d); + return FromMillistokes(millistokes.Value); } else { @@ -274,7 +274,7 @@ public static KinematicViscosity FromStokes(double stokes) { if (nanostokes.HasValue) { - return new KinematicViscosity((nanostokes.Value/1e4) * 1e-9d); + return FromNanostokes(nanostokes.Value); } else { @@ -289,7 +289,7 @@ public static KinematicViscosity FromStokes(double stokes) { if (squaremeterspersecond.HasValue) { - return new KinematicViscosity(squaremeterspersecond.Value); + return FromSquareMetersPerSecond(squaremeterspersecond.Value); } else { @@ -304,7 +304,7 @@ public static KinematicViscosity FromStokes(double stokes) { if (stokes.HasValue) { - return new KinematicViscosity(stokes.Value/1e4); + return FromStokes(stokes.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs index 5dfedcd27f..6fad6c79da 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs @@ -295,7 +295,7 @@ public static Length FromYards(double yards) { if (centimeters.HasValue) { - return new Length((centimeters.Value) * 1e-2d); + return FromCentimeters(centimeters.Value); } else { @@ -310,7 +310,7 @@ public static Length FromYards(double yards) { if (decimeters.HasValue) { - return new Length((decimeters.Value) * 1e-1d); + return FromDecimeters(decimeters.Value); } else { @@ -325,7 +325,7 @@ public static Length FromYards(double yards) { if (feet.HasValue) { - return new Length(feet.Value*0.3048); + return FromFeet(feet.Value); } else { @@ -340,7 +340,7 @@ public static Length FromYards(double yards) { if (inches.HasValue) { - return new Length(inches.Value*2.54e-2); + return FromInches(inches.Value); } else { @@ -355,7 +355,7 @@ public static Length FromYards(double yards) { if (kilometers.HasValue) { - return new Length((kilometers.Value) * 1e3d); + return FromKilometers(kilometers.Value); } else { @@ -370,7 +370,7 @@ public static Length FromYards(double yards) { if (meters.HasValue) { - return new Length(meters.Value); + return FromMeters(meters.Value); } else { @@ -385,7 +385,7 @@ public static Length FromYards(double yards) { if (microinches.HasValue) { - return new Length(microinches.Value*2.54e-8); + return FromMicroinches(microinches.Value); } else { @@ -400,7 +400,7 @@ public static Length FromYards(double yards) { if (micrometers.HasValue) { - return new Length((micrometers.Value) * 1e-6d); + return FromMicrometers(micrometers.Value); } else { @@ -415,7 +415,7 @@ public static Length FromYards(double yards) { if (mils.HasValue) { - return new Length(mils.Value*2.54e-5); + return FromMils(mils.Value); } else { @@ -430,7 +430,7 @@ public static Length FromYards(double yards) { if (miles.HasValue) { - return new Length(miles.Value*1609.34); + return FromMiles(miles.Value); } else { @@ -445,7 +445,7 @@ public static Length FromYards(double yards) { if (millimeters.HasValue) { - return new Length((millimeters.Value) * 1e-3d); + return FromMillimeters(millimeters.Value); } else { @@ -460,7 +460,7 @@ public static Length FromYards(double yards) { if (nanometers.HasValue) { - return new Length((nanometers.Value) * 1e-9d); + return FromNanometers(nanometers.Value); } else { @@ -475,7 +475,7 @@ public static Length FromYards(double yards) { if (nauticalmiles.HasValue) { - return new Length(nauticalmiles.Value*1852); + return FromNauticalMiles(nauticalmiles.Value); } else { @@ -490,7 +490,7 @@ public static Length FromYards(double yards) { if (yards.HasValue) { - return new Length(yards.Value*0.9144); + return FromYards(yards.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs index 9f12044eca..2f909295b8 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs @@ -103,7 +103,7 @@ public static Level FromNepers(double nepers) { if (decibels.HasValue) { - return new Level(decibels.Value); + return FromDecibels(decibels.Value); } else { @@ -118,7 +118,7 @@ public static Level FromNepers(double nepers) { if (nepers.HasValue) { - return new Level((1/0.115129254)*nepers.Value); + return FromNepers(nepers.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs index 9debfacf2f..da440d22ad 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs @@ -343,7 +343,7 @@ public static Mass FromTonnes(double tonnes) { if (centigrams.HasValue) { - return new Mass((centigrams.Value/1e3) * 1e-2d); + return FromCentigrams(centigrams.Value); } else { @@ -358,7 +358,7 @@ public static Mass FromTonnes(double tonnes) { if (decagrams.HasValue) { - return new Mass((decagrams.Value/1e3) * 1e1d); + return FromDecagrams(decagrams.Value); } else { @@ -373,7 +373,7 @@ public static Mass FromTonnes(double tonnes) { if (decigrams.HasValue) { - return new Mass((decigrams.Value/1e3) * 1e-1d); + return FromDecigrams(decigrams.Value); } else { @@ -388,7 +388,7 @@ public static Mass FromTonnes(double tonnes) { if (grams.HasValue) { - return new Mass(grams.Value/1e3); + return FromGrams(grams.Value); } else { @@ -403,7 +403,7 @@ public static Mass FromTonnes(double tonnes) { if (hectograms.HasValue) { - return new Mass((hectograms.Value/1e3) * 1e2d); + return FromHectograms(hectograms.Value); } else { @@ -418,7 +418,7 @@ public static Mass FromTonnes(double tonnes) { if (kilograms.HasValue) { - return new Mass((kilograms.Value/1e3) * 1e3d); + return FromKilograms(kilograms.Value); } else { @@ -433,7 +433,7 @@ public static Mass FromTonnes(double tonnes) { if (kilotonnes.HasValue) { - return new Mass((kilotonnes.Value*1e3) * 1e3d); + return FromKilotonnes(kilotonnes.Value); } else { @@ -448,7 +448,7 @@ public static Mass FromTonnes(double tonnes) { if (longtons.HasValue) { - return new Mass(longtons.Value*1016.0469088); + return FromLongTons(longtons.Value); } else { @@ -463,7 +463,7 @@ public static Mass FromTonnes(double tonnes) { if (megatonnes.HasValue) { - return new Mass((megatonnes.Value*1e3) * 1e6d); + return FromMegatonnes(megatonnes.Value); } else { @@ -478,7 +478,7 @@ public static Mass FromTonnes(double tonnes) { if (micrograms.HasValue) { - return new Mass((micrograms.Value/1e3) * 1e-6d); + return FromMicrograms(micrograms.Value); } else { @@ -493,7 +493,7 @@ public static Mass FromTonnes(double tonnes) { if (milligrams.HasValue) { - return new Mass((milligrams.Value/1e3) * 1e-3d); + return FromMilligrams(milligrams.Value); } else { @@ -508,7 +508,7 @@ public static Mass FromTonnes(double tonnes) { if (nanograms.HasValue) { - return new Mass((nanograms.Value/1e3) * 1e-9d); + return FromNanograms(nanograms.Value); } else { @@ -523,7 +523,7 @@ public static Mass FromTonnes(double tonnes) { if (ounces.HasValue) { - return new Mass(ounces.Value/35.2739619); + return FromOunces(ounces.Value); } else { @@ -538,7 +538,7 @@ public static Mass FromTonnes(double tonnes) { if (pounds.HasValue) { - return new Mass(pounds.Value*0.45359237); + return FromPounds(pounds.Value); } else { @@ -553,7 +553,7 @@ public static Mass FromTonnes(double tonnes) { if (shorttons.HasValue) { - return new Mass(shorttons.Value*907.18474); + return FromShortTons(shorttons.Value); } else { @@ -568,7 +568,7 @@ public static Mass FromTonnes(double tonnes) { if (stone.HasValue) { - return new Mass(stone.Value/0.1574731728702698); + return FromStone(stone.Value); } else { @@ -583,7 +583,7 @@ public static Mass FromTonnes(double tonnes) { if (tonnes.HasValue) { - return new Mass(tonnes.Value*1e3); + return FromTonnes(tonnes.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs index 9f8bbc4f32..3fc05f5646 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs @@ -231,7 +231,7 @@ public static MassFlow FromTonnesPerDay(double tonnesperday) { if (centigramspersecond.HasValue) { - return new MassFlow((centigramspersecond.Value) * 1e-2d); + return FromCentigramsPerSecond(centigramspersecond.Value); } else { @@ -246,7 +246,7 @@ public static MassFlow FromTonnesPerDay(double tonnesperday) { if (decagramspersecond.HasValue) { - return new MassFlow((decagramspersecond.Value) * 1e1d); + return FromDecagramsPerSecond(decagramspersecond.Value); } else { @@ -261,7 +261,7 @@ public static MassFlow FromTonnesPerDay(double tonnesperday) { if (decigramspersecond.HasValue) { - return new MassFlow((decigramspersecond.Value) * 1e-1d); + return FromDecigramsPerSecond(decigramspersecond.Value); } else { @@ -276,7 +276,7 @@ public static MassFlow FromTonnesPerDay(double tonnesperday) { if (gramspersecond.HasValue) { - return new MassFlow(gramspersecond.Value); + return FromGramsPerSecond(gramspersecond.Value); } else { @@ -291,7 +291,7 @@ public static MassFlow FromTonnesPerDay(double tonnesperday) { if (hectogramspersecond.HasValue) { - return new MassFlow((hectogramspersecond.Value) * 1e2d); + return FromHectogramsPerSecond(hectogramspersecond.Value); } else { @@ -306,7 +306,7 @@ public static MassFlow FromTonnesPerDay(double tonnesperday) { if (kilogramspersecond.HasValue) { - return new MassFlow((kilogramspersecond.Value) * 1e3d); + return FromKilogramsPerSecond(kilogramspersecond.Value); } else { @@ -321,7 +321,7 @@ public static MassFlow FromTonnesPerDay(double tonnesperday) { if (microgramspersecond.HasValue) { - return new MassFlow((microgramspersecond.Value) * 1e-6d); + return FromMicrogramsPerSecond(microgramspersecond.Value); } else { @@ -336,7 +336,7 @@ public static MassFlow FromTonnesPerDay(double tonnesperday) { if (milligramspersecond.HasValue) { - return new MassFlow((milligramspersecond.Value) * 1e-3d); + return FromMilligramsPerSecond(milligramspersecond.Value); } else { @@ -351,7 +351,7 @@ public static MassFlow FromTonnesPerDay(double tonnesperday) { if (nanogramspersecond.HasValue) { - return new MassFlow((nanogramspersecond.Value) * 1e-9d); + return FromNanogramsPerSecond(nanogramspersecond.Value); } else { @@ -366,7 +366,7 @@ public static MassFlow FromTonnesPerDay(double tonnesperday) { if (tonnesperday.HasValue) { - return new MassFlow(tonnesperday.Value/0.0864000); + return FromTonnesPerDay(tonnesperday.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs index bb204b4604..b43ad6e2e9 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs @@ -327,7 +327,7 @@ public static Power FromWatts(double watts) { if (boilerhorsepower.HasValue) { - return new Power(Convert.ToDecimal(boilerhorsepower.Value*9812.5d)); + return FromBoilerHorsepower(boilerhorsepower.Value); } else { @@ -342,7 +342,7 @@ public static Power FromWatts(double watts) { if (electricalhorsepower.HasValue) { - return new Power(Convert.ToDecimal(electricalhorsepower.Value*746d)); + return FromElectricalHorsepower(electricalhorsepower.Value); } else { @@ -357,7 +357,7 @@ public static Power FromWatts(double watts) { if (femtowatts.HasValue) { - return new Power(Convert.ToDecimal((femtowatts.Value) * 1e-15d)); + return FromFemtowatts(femtowatts.Value); } else { @@ -372,7 +372,7 @@ public static Power FromWatts(double watts) { if (gigawatts.HasValue) { - return new Power(Convert.ToDecimal((gigawatts.Value) * 1e9d)); + return FromGigawatts(gigawatts.Value); } else { @@ -387,7 +387,7 @@ public static Power FromWatts(double watts) { if (hydraulichorsepower.HasValue) { - return new Power(Convert.ToDecimal(hydraulichorsepower.Value*745.69988145d)); + return FromHydraulicHorsepower(hydraulichorsepower.Value); } else { @@ -402,7 +402,7 @@ public static Power FromWatts(double watts) { if (kilowatts.HasValue) { - return new Power(Convert.ToDecimal((kilowatts.Value) * 1e3d)); + return FromKilowatts(kilowatts.Value); } else { @@ -417,7 +417,7 @@ public static Power FromWatts(double watts) { if (mechanicalhorsepower.HasValue) { - return new Power(Convert.ToDecimal(mechanicalhorsepower.Value*745.69d)); + return FromMechanicalHorsepower(mechanicalhorsepower.Value); } else { @@ -432,7 +432,7 @@ public static Power FromWatts(double watts) { if (megawatts.HasValue) { - return new Power(Convert.ToDecimal((megawatts.Value) * 1e6d)); + return FromMegawatts(megawatts.Value); } else { @@ -447,7 +447,7 @@ public static Power FromWatts(double watts) { if (metrichorsepower.HasValue) { - return new Power(Convert.ToDecimal(metrichorsepower.Value*735.49875d)); + return FromMetricHorsepower(metrichorsepower.Value); } else { @@ -462,7 +462,7 @@ public static Power FromWatts(double watts) { if (microwatts.HasValue) { - return new Power(Convert.ToDecimal((microwatts.Value) * 1e-6d)); + return FromMicrowatts(microwatts.Value); } else { @@ -477,7 +477,7 @@ public static Power FromWatts(double watts) { if (milliwatts.HasValue) { - return new Power(Convert.ToDecimal((milliwatts.Value) * 1e-3d)); + return FromMilliwatts(milliwatts.Value); } else { @@ -492,7 +492,7 @@ public static Power FromWatts(double watts) { if (nanowatts.HasValue) { - return new Power(Convert.ToDecimal((nanowatts.Value) * 1e-9d)); + return FromNanowatts(nanowatts.Value); } else { @@ -507,7 +507,7 @@ public static Power FromWatts(double watts) { if (petawatts.HasValue) { - return new Power(Convert.ToDecimal((petawatts.Value) * 1e15d)); + return FromPetawatts(petawatts.Value); } else { @@ -522,7 +522,7 @@ public static Power FromWatts(double watts) { if (picowatts.HasValue) { - return new Power(Convert.ToDecimal((picowatts.Value) * 1e-12d)); + return FromPicowatts(picowatts.Value); } else { @@ -537,7 +537,7 @@ public static Power FromWatts(double watts) { if (terawatts.HasValue) { - return new Power(Convert.ToDecimal((terawatts.Value) * 1e12d)); + return FromTerawatts(terawatts.Value); } else { @@ -552,7 +552,7 @@ public static Power FromWatts(double watts) { if (watts.HasValue) { - return new Power(Convert.ToDecimal(watts.Value)); + return FromWatts(watts.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs index 220997b94e..b038e7785b 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs @@ -103,7 +103,7 @@ public static PowerRatio FromDecibelWatts(double decibelwatts) { if (decibelmilliwatts.HasValue) { - return new PowerRatio(decibelmilliwatts.Value - 30); + return FromDecibelMilliwatts(decibelmilliwatts.Value); } else { @@ -118,7 +118,7 @@ public static PowerRatio FromDecibelWatts(double decibelwatts) { if (decibelwatts.HasValue) { - return new PowerRatio(decibelwatts.Value); + return FromDecibelWatts(decibelwatts.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs index f9747f3a49..55fa3cf395 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs @@ -599,7 +599,7 @@ public static Pressure FromTorrs(double torrs) { if (atmospheres.HasValue) { - return new Pressure(atmospheres.Value*1.01325*1e5); + return FromAtmospheres(atmospheres.Value); } else { @@ -614,7 +614,7 @@ public static Pressure FromTorrs(double torrs) { if (bars.HasValue) { - return new Pressure(bars.Value*1e5); + return FromBars(bars.Value); } else { @@ -629,7 +629,7 @@ public static Pressure FromTorrs(double torrs) { if (centibars.HasValue) { - return new Pressure((centibars.Value*1e5) * 1e-2d); + return FromCentibars(centibars.Value); } else { @@ -644,7 +644,7 @@ public static Pressure FromTorrs(double torrs) { if (decapascals.HasValue) { - return new Pressure((decapascals.Value) * 1e1d); + return FromDecapascals(decapascals.Value); } else { @@ -659,7 +659,7 @@ public static Pressure FromTorrs(double torrs) { if (decibars.HasValue) { - return new Pressure((decibars.Value*1e5) * 1e-1d); + return FromDecibars(decibars.Value); } else { @@ -674,7 +674,7 @@ public static Pressure FromTorrs(double torrs) { if (gigapascals.HasValue) { - return new Pressure((gigapascals.Value) * 1e9d); + return FromGigapascals(gigapascals.Value); } else { @@ -689,7 +689,7 @@ public static Pressure FromTorrs(double torrs) { if (hectopascals.HasValue) { - return new Pressure((hectopascals.Value) * 1e2d); + return FromHectopascals(hectopascals.Value); } else { @@ -704,7 +704,7 @@ public static Pressure FromTorrs(double torrs) { if (kilobars.HasValue) { - return new Pressure((kilobars.Value*1e5) * 1e3d); + return FromKilobars(kilobars.Value); } else { @@ -719,7 +719,7 @@ public static Pressure FromTorrs(double torrs) { if (kilogramsforcepersquarecentimeter.HasValue) { - return new Pressure(kilogramsforcepersquarecentimeter.Value*9.80665*1e4); + return FromKilogramsForcePerSquareCentimeter(kilogramsforcepersquarecentimeter.Value); } else { @@ -734,7 +734,7 @@ public static Pressure FromTorrs(double torrs) { if (kilogramsforcepersquaremeter.HasValue) { - return new Pressure(kilogramsforcepersquaremeter.Value*9.80665019960652); + return FromKilogramsForcePerSquareMeter(kilogramsforcepersquaremeter.Value); } else { @@ -749,7 +749,7 @@ public static Pressure FromTorrs(double torrs) { if (kilogramsforcepersquaremillimeter.HasValue) { - return new Pressure(kilogramsforcepersquaremillimeter.Value*9806650.19960652); + return FromKilogramsForcePerSquareMillimeter(kilogramsforcepersquaremillimeter.Value); } else { @@ -764,7 +764,7 @@ public static Pressure FromTorrs(double torrs) { if (kilonewtonspersquarecentimeter.HasValue) { - return new Pressure((kilonewtonspersquarecentimeter.Value*1e4) * 1e3d); + return FromKilonewtonsPerSquareCentimeter(kilonewtonspersquarecentimeter.Value); } else { @@ -779,7 +779,7 @@ public static Pressure FromTorrs(double torrs) { if (kilonewtonspersquaremeter.HasValue) { - return new Pressure((kilonewtonspersquaremeter.Value) * 1e3d); + return FromKilonewtonsPerSquareMeter(kilonewtonspersquaremeter.Value); } else { @@ -794,7 +794,7 @@ public static Pressure FromTorrs(double torrs) { if (kilonewtonspersquaremillimeter.HasValue) { - return new Pressure((kilonewtonspersquaremillimeter.Value*1e6) * 1e3d); + return FromKilonewtonsPerSquareMillimeter(kilonewtonspersquaremillimeter.Value); } else { @@ -809,7 +809,7 @@ public static Pressure FromTorrs(double torrs) { if (kilopascals.HasValue) { - return new Pressure((kilopascals.Value) * 1e3d); + return FromKilopascals(kilopascals.Value); } else { @@ -824,7 +824,7 @@ public static Pressure FromTorrs(double torrs) { if (kilopoundsforcepersquarefoot.HasValue) { - return new Pressure((kilopoundsforcepersquarefoot.Value*47.8802631216372) * 1e3d); + return FromKilopoundsForcePerSquareFoot(kilopoundsforcepersquarefoot.Value); } else { @@ -839,7 +839,7 @@ public static Pressure FromTorrs(double torrs) { if (kilopoundsforcepersquareinch.HasValue) { - return new Pressure((kilopoundsforcepersquareinch.Value*6894.75788951576) * 1e3d); + return FromKilopoundsForcePerSquareInch(kilopoundsforcepersquareinch.Value); } else { @@ -854,7 +854,7 @@ public static Pressure FromTorrs(double torrs) { if (megabars.HasValue) { - return new Pressure((megabars.Value*1e5) * 1e6d); + return FromMegabars(megabars.Value); } else { @@ -869,7 +869,7 @@ public static Pressure FromTorrs(double torrs) { if (megapascals.HasValue) { - return new Pressure((megapascals.Value) * 1e6d); + return FromMegapascals(megapascals.Value); } else { @@ -884,7 +884,7 @@ public static Pressure FromTorrs(double torrs) { if (micropascals.HasValue) { - return new Pressure((micropascals.Value) * 1e-6d); + return FromMicropascals(micropascals.Value); } else { @@ -899,7 +899,7 @@ public static Pressure FromTorrs(double torrs) { if (millibars.HasValue) { - return new Pressure((millibars.Value*1e5) * 1e-3d); + return FromMillibars(millibars.Value); } else { @@ -914,7 +914,7 @@ public static Pressure FromTorrs(double torrs) { if (newtonspersquarecentimeter.HasValue) { - return new Pressure(newtonspersquarecentimeter.Value*1e4); + return FromNewtonsPerSquareCentimeter(newtonspersquarecentimeter.Value); } else { @@ -929,7 +929,7 @@ public static Pressure FromTorrs(double torrs) { if (newtonspersquaremeter.HasValue) { - return new Pressure(newtonspersquaremeter.Value); + return FromNewtonsPerSquareMeter(newtonspersquaremeter.Value); } else { @@ -944,7 +944,7 @@ public static Pressure FromTorrs(double torrs) { if (newtonspersquaremillimeter.HasValue) { - return new Pressure(newtonspersquaremillimeter.Value*1e6); + return FromNewtonsPerSquareMillimeter(newtonspersquaremillimeter.Value); } else { @@ -959,7 +959,7 @@ public static Pressure FromTorrs(double torrs) { if (pascals.HasValue) { - return new Pressure(pascals.Value); + return FromPascals(pascals.Value); } else { @@ -974,7 +974,7 @@ public static Pressure FromTorrs(double torrs) { if (poundsforcepersquarefoot.HasValue) { - return new Pressure(poundsforcepersquarefoot.Value*47.8802631216372); + return FromPoundsForcePerSquareFoot(poundsforcepersquarefoot.Value); } else { @@ -989,7 +989,7 @@ public static Pressure FromTorrs(double torrs) { if (poundsforcepersquareinch.HasValue) { - return new Pressure(poundsforcepersquareinch.Value*6894.75788951576); + return FromPoundsForcePerSquareInch(poundsforcepersquareinch.Value); } else { @@ -1004,7 +1004,7 @@ public static Pressure FromTorrs(double torrs) { if (psi.HasValue) { - return new Pressure(psi.Value*6.89464975179*1e3); + return FromPsi(psi.Value); } else { @@ -1019,7 +1019,7 @@ public static Pressure FromTorrs(double torrs) { if (technicalatmospheres.HasValue) { - return new Pressure(technicalatmospheres.Value*9.80680592331*1e4); + return FromTechnicalAtmospheres(technicalatmospheres.Value); } else { @@ -1034,7 +1034,7 @@ public static Pressure FromTorrs(double torrs) { if (tonnesforcepersquarecentimeter.HasValue) { - return new Pressure(tonnesforcepersquarecentimeter.Value*98066501.9960652); + return FromTonnesForcePerSquareCentimeter(tonnesforcepersquarecentimeter.Value); } else { @@ -1049,7 +1049,7 @@ public static Pressure FromTorrs(double torrs) { if (tonnesforcepersquaremeter.HasValue) { - return new Pressure(tonnesforcepersquaremeter.Value*9806.65019960653); + return FromTonnesForcePerSquareMeter(tonnesforcepersquaremeter.Value); } else { @@ -1064,7 +1064,7 @@ public static Pressure FromTorrs(double torrs) { if (tonnesforcepersquaremillimeter.HasValue) { - return new Pressure(tonnesforcepersquaremillimeter.Value*9806650199.60653); + return FromTonnesForcePerSquareMillimeter(tonnesforcepersquaremillimeter.Value); } else { @@ -1079,7 +1079,7 @@ public static Pressure FromTorrs(double torrs) { if (torrs.HasValue) { - return new Pressure(torrs.Value*1.3332266752*1e2); + return FromTorrs(torrs.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs index 8b41d3c16c..4cc2002765 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs @@ -135,7 +135,7 @@ public static PressureChangeRate FromPascalsPerSecond(double pascalspersecond) { if (atmospherespersecond.HasValue) { - return new PressureChangeRate(atmospherespersecond.Value * 1.01325*1e5); + return FromAtmospheresPerSecond(atmospherespersecond.Value); } else { @@ -150,7 +150,7 @@ public static PressureChangeRate FromPascalsPerSecond(double pascalspersecond) { if (kilopascalspersecond.HasValue) { - return new PressureChangeRate((kilopascalspersecond.Value) * 1e3d); + return FromKilopascalsPerSecond(kilopascalspersecond.Value); } else { @@ -165,7 +165,7 @@ public static PressureChangeRate FromPascalsPerSecond(double pascalspersecond) { if (megapascalspersecond.HasValue) { - return new PressureChangeRate((megapascalspersecond.Value) * 1e6d); + return FromMegapascalsPerSecond(megapascalspersecond.Value); } else { @@ -180,7 +180,7 @@ public static PressureChangeRate FromPascalsPerSecond(double pascalspersecond) { if (pascalspersecond.HasValue) { - return new PressureChangeRate(pascalspersecond.Value); + return FromPascalsPerSecond(pascalspersecond.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs index 3777b2a580..9b89e45d6b 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs @@ -167,7 +167,7 @@ public static Ratio FromPercent(double percent) { if (decimalfractions.HasValue) { - return new Ratio(decimalfractions.Value); + return FromDecimalFractions(decimalfractions.Value); } else { @@ -182,7 +182,7 @@ public static Ratio FromPercent(double percent) { if (partsperbillion.HasValue) { - return new Ratio(partsperbillion.Value/1e9); + return FromPartsPerBillion(partsperbillion.Value); } else { @@ -197,7 +197,7 @@ public static Ratio FromPercent(double percent) { if (partspermillion.HasValue) { - return new Ratio(partspermillion.Value/1e6); + return FromPartsPerMillion(partspermillion.Value); } else { @@ -212,7 +212,7 @@ public static Ratio FromPercent(double percent) { if (partsperthousand.HasValue) { - return new Ratio(partsperthousand.Value/1e3); + return FromPartsPerThousand(partsperthousand.Value); } else { @@ -227,7 +227,7 @@ public static Ratio FromPercent(double percent) { if (partspertrillion.HasValue) { - return new Ratio(partspertrillion.Value/1e12); + return FromPartsPerTrillion(partspertrillion.Value); } else { @@ -242,7 +242,7 @@ public static Ratio FromPercent(double percent) { if (percent.HasValue) { - return new Ratio(percent.Value/1e2); + return FromPercent(percent.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs index 3a43f04e9a..bfa5733e21 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs @@ -199,7 +199,7 @@ public static RotationalSpeed FromRevolutionsPerSecond(double revolutionsperseco { if (centiradianspersecond.HasValue) { - return new RotationalSpeed((centiradianspersecond.Value) * 1e-2d); + return FromCentiradiansPerSecond(centiradianspersecond.Value); } else { @@ -214,7 +214,7 @@ public static RotationalSpeed FromRevolutionsPerSecond(double revolutionsperseco { if (deciradianspersecond.HasValue) { - return new RotationalSpeed((deciradianspersecond.Value) * 1e-1d); + return FromDeciradiansPerSecond(deciradianspersecond.Value); } else { @@ -229,7 +229,7 @@ public static RotationalSpeed FromRevolutionsPerSecond(double revolutionsperseco { if (microradianspersecond.HasValue) { - return new RotationalSpeed((microradianspersecond.Value) * 1e-6d); + return FromMicroradiansPerSecond(microradianspersecond.Value); } else { @@ -244,7 +244,7 @@ public static RotationalSpeed FromRevolutionsPerSecond(double revolutionsperseco { if (milliradianspersecond.HasValue) { - return new RotationalSpeed((milliradianspersecond.Value) * 1e-3d); + return FromMilliradiansPerSecond(milliradianspersecond.Value); } else { @@ -259,7 +259,7 @@ public static RotationalSpeed FromRevolutionsPerSecond(double revolutionsperseco { if (nanoradianspersecond.HasValue) { - return new RotationalSpeed((nanoradianspersecond.Value) * 1e-9d); + return FromNanoradiansPerSecond(nanoradianspersecond.Value); } else { @@ -274,7 +274,7 @@ public static RotationalSpeed FromRevolutionsPerSecond(double revolutionsperseco { if (radianspersecond.HasValue) { - return new RotationalSpeed(radianspersecond.Value); + return FromRadiansPerSecond(radianspersecond.Value); } else { @@ -289,7 +289,7 @@ public static RotationalSpeed FromRevolutionsPerSecond(double revolutionsperseco { if (revolutionsperminute.HasValue) { - return new RotationalSpeed((revolutionsperminute.Value*6.2831853072)/60); + return FromRevolutionsPerMinute(revolutionsperminute.Value); } else { @@ -304,7 +304,7 @@ public static RotationalSpeed FromRevolutionsPerSecond(double revolutionsperseco { if (revolutionspersecond.HasValue) { - return new RotationalSpeed(revolutionspersecond.Value*6.2831853072); + return FromRevolutionsPerSecond(revolutionspersecond.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs index 4e0fc03144..f1c2fab79a 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs @@ -199,7 +199,7 @@ public static SpecificEnergy FromWattHoursPerKilogram(double watthoursperkilogra { if (caloriespergram.HasValue) { - return new SpecificEnergy(caloriespergram.Value*4.184e3); + return FromCaloriesPerGram(caloriespergram.Value); } else { @@ -214,7 +214,7 @@ public static SpecificEnergy FromWattHoursPerKilogram(double watthoursperkilogra { if (joulesperkilogram.HasValue) { - return new SpecificEnergy(joulesperkilogram.Value); + return FromJoulesPerKilogram(joulesperkilogram.Value); } else { @@ -229,7 +229,7 @@ public static SpecificEnergy FromWattHoursPerKilogram(double watthoursperkilogra { if (kilocaloriespergram.HasValue) { - return new SpecificEnergy((kilocaloriespergram.Value*4.184e3) * 1e3d); + return FromKilocaloriesPerGram(kilocaloriespergram.Value); } else { @@ -244,7 +244,7 @@ public static SpecificEnergy FromWattHoursPerKilogram(double watthoursperkilogra { if (kilojoulesperkilogram.HasValue) { - return new SpecificEnergy((kilojoulesperkilogram.Value) * 1e3d); + return FromKilojoulesPerKilogram(kilojoulesperkilogram.Value); } else { @@ -259,7 +259,7 @@ public static SpecificEnergy FromWattHoursPerKilogram(double watthoursperkilogra { if (kilowatthoursperkilogram.HasValue) { - return new SpecificEnergy((kilowatthoursperkilogram.Value*3.6e3) * 1e3d); + return FromKilowattHoursPerKilogram(kilowatthoursperkilogram.Value); } else { @@ -274,7 +274,7 @@ public static SpecificEnergy FromWattHoursPerKilogram(double watthoursperkilogra { if (megajoulesperkilogram.HasValue) { - return new SpecificEnergy((megajoulesperkilogram.Value) * 1e6d); + return FromMegajoulesPerKilogram(megajoulesperkilogram.Value); } else { @@ -289,7 +289,7 @@ public static SpecificEnergy FromWattHoursPerKilogram(double watthoursperkilogra { if (megawatthoursperkilogram.HasValue) { - return new SpecificEnergy((megawatthoursperkilogram.Value*3.6e3) * 1e6d); + return FromMegawattHoursPerKilogram(megawatthoursperkilogram.Value); } else { @@ -304,7 +304,7 @@ public static SpecificEnergy FromWattHoursPerKilogram(double watthoursperkilogra { if (watthoursperkilogram.HasValue) { - return new SpecificEnergy(watthoursperkilogram.Value*3.6e3); + return FromWattHoursPerKilogram(watthoursperkilogram.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs index 2725595321..dd2bc3b01f 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs @@ -327,7 +327,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc { if (kilogramsforcepercubiccentimeter.HasValue) { - return new SpecificWeight(kilogramsforcepercubiccentimeter.Value*9806650.19960652); + return FromKilogramsForcePerCubicCentimeter(kilogramsforcepercubiccentimeter.Value); } else { @@ -342,7 +342,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc { if (kilogramsforcepercubicmeter.HasValue) { - return new SpecificWeight(kilogramsforcepercubicmeter.Value*9.80665019960652); + return FromKilogramsForcePerCubicMeter(kilogramsforcepercubicmeter.Value); } else { @@ -357,7 +357,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc { if (kilogramsforcepercubicmillimeter.HasValue) { - return new SpecificWeight(kilogramsforcepercubicmillimeter.Value*9806650199.60653); + return FromKilogramsForcePerCubicMillimeter(kilogramsforcepercubicmillimeter.Value); } else { @@ -372,7 +372,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc { if (kilonewtonspercubiccentimeter.HasValue) { - return new SpecificWeight((kilonewtonspercubiccentimeter.Value*1000000) * 1e3d); + return FromKilonewtonsPerCubicCentimeter(kilonewtonspercubiccentimeter.Value); } else { @@ -387,7 +387,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc { if (kilonewtonspercubicmeter.HasValue) { - return new SpecificWeight((kilonewtonspercubicmeter.Value) * 1e3d); + return FromKilonewtonsPerCubicMeter(kilonewtonspercubicmeter.Value); } else { @@ -402,7 +402,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc { if (kilonewtonspercubicmillimeter.HasValue) { - return new SpecificWeight((kilonewtonspercubicmillimeter.Value*1000000000) * 1e3d); + return FromKilonewtonsPerCubicMillimeter(kilonewtonspercubicmillimeter.Value); } else { @@ -417,7 +417,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc { if (kilopoundsforcepercubicfoot.HasValue) { - return new SpecificWeight((kilopoundsforcepercubicfoot.Value*157.087477433193) * 1e3d); + return FromKilopoundsForcePerCubicFoot(kilopoundsforcepercubicfoot.Value); } else { @@ -432,7 +432,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc { if (kilopoundsforcepercubicinch.HasValue) { - return new SpecificWeight((kilopoundsforcepercubicinch.Value*271447.161004558) * 1e3d); + return FromKilopoundsForcePerCubicInch(kilopoundsforcepercubicinch.Value); } else { @@ -447,7 +447,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc { if (newtonspercubiccentimeter.HasValue) { - return new SpecificWeight(newtonspercubiccentimeter.Value*1000000); + return FromNewtonsPerCubicCentimeter(newtonspercubiccentimeter.Value); } else { @@ -462,7 +462,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc { if (newtonspercubicmeter.HasValue) { - return new SpecificWeight(newtonspercubicmeter.Value); + return FromNewtonsPerCubicMeter(newtonspercubicmeter.Value); } else { @@ -477,7 +477,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc { if (newtonspercubicmillimeter.HasValue) { - return new SpecificWeight(newtonspercubicmillimeter.Value*1000000000); + return FromNewtonsPerCubicMillimeter(newtonspercubicmillimeter.Value); } else { @@ -492,7 +492,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc { if (poundsforcepercubicfoot.HasValue) { - return new SpecificWeight(poundsforcepercubicfoot.Value*157.087477433193); + return FromPoundsForcePerCubicFoot(poundsforcepercubicfoot.Value); } else { @@ -507,7 +507,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc { if (poundsforcepercubicinch.HasValue) { - return new SpecificWeight(poundsforcepercubicinch.Value*271447.161004558); + return FromPoundsForcePerCubicInch(poundsforcepercubicinch.Value); } else { @@ -522,7 +522,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc { if (tonnesforcepercubiccentimeter.HasValue) { - return new SpecificWeight(tonnesforcepercubiccentimeter.Value*9806650199.60653); + return FromTonnesForcePerCubicCentimeter(tonnesforcepercubiccentimeter.Value); } else { @@ -537,7 +537,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc { if (tonnesforcepercubicmeter.HasValue) { - return new SpecificWeight(tonnesforcepercubicmeter.Value*9806.65019960653); + return FromTonnesForcePerCubicMeter(tonnesforcepercubicmeter.Value); } else { @@ -552,7 +552,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc { if (tonnesforcepercubicmillimeter.HasValue) { - return new SpecificWeight(tonnesforcepercubicmillimeter.Value*9806650199606.53); + return FromTonnesForcePerCubicMillimeter(tonnesforcepercubicmillimeter.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs index f1acd36104..1036a37a4f 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs @@ -263,7 +263,7 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) { if (centimeterspersecond.HasValue) { - return new Speed((centimeterspersecond.Value) * 1e-2d); + return FromCentimetersPerSecond(centimeterspersecond.Value); } else { @@ -278,7 +278,7 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) { if (decimeterspersecond.HasValue) { - return new Speed((decimeterspersecond.Value) * 1e-1d); + return FromDecimetersPerSecond(decimeterspersecond.Value); } else { @@ -293,7 +293,7 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) { if (feetpersecond.HasValue) { - return new Speed(feetpersecond.Value*0.3048); + return FromFeetPerSecond(feetpersecond.Value); } else { @@ -308,7 +308,7 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) { if (kilometersperhour.HasValue) { - return new Speed(kilometersperhour.Value/3.6); + return FromKilometersPerHour(kilometersperhour.Value); } else { @@ -323,7 +323,7 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) { if (kilometerspersecond.HasValue) { - return new Speed((kilometerspersecond.Value) * 1e3d); + return FromKilometersPerSecond(kilometerspersecond.Value); } else { @@ -338,7 +338,7 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) { if (knots.HasValue) { - return new Speed(knots.Value*0.514444); + return FromKnots(knots.Value); } else { @@ -353,7 +353,7 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) { if (metersperhour.HasValue) { - return new Speed(metersperhour.Value/3600); + return FromMetersPerHour(metersperhour.Value); } else { @@ -368,7 +368,7 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) { if (meterspersecond.HasValue) { - return new Speed(meterspersecond.Value); + return FromMetersPerSecond(meterspersecond.Value); } else { @@ -383,7 +383,7 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) { if (micrometerspersecond.HasValue) { - return new Speed((micrometerspersecond.Value) * 1e-6d); + return FromMicrometersPerSecond(micrometerspersecond.Value); } else { @@ -398,7 +398,7 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) { if (milesperhour.HasValue) { - return new Speed(milesperhour.Value*0.44704); + return FromMilesPerHour(milesperhour.Value); } else { @@ -413,7 +413,7 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) { if (millimeterspersecond.HasValue) { - return new Speed((millimeterspersecond.Value) * 1e-3d); + return FromMillimetersPerSecond(millimeterspersecond.Value); } else { @@ -428,7 +428,7 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) { if (nanometerspersecond.HasValue) { - return new Speed((nanometerspersecond.Value) * 1e-9d); + return FromNanometersPerSecond(nanometerspersecond.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs index 9d5bb82150..eaee3a5316 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs @@ -199,7 +199,7 @@ public static Temperature FromKelvins(double kelvins) { if (degreescelsius.HasValue) { - return new Temperature(degreescelsius.Value + 273.15); + return FromDegreesCelsius(degreescelsius.Value); } else { @@ -214,7 +214,7 @@ public static Temperature FromKelvins(double kelvins) { if (degreesdelisle.HasValue) { - return new Temperature(degreesdelisle.Value*-2/3 + 373.15); + return FromDegreesDelisle(degreesdelisle.Value); } else { @@ -229,7 +229,7 @@ public static Temperature FromKelvins(double kelvins) { if (degreesfahrenheit.HasValue) { - return new Temperature(degreesfahrenheit.Value*5/9 + 459.67*5/9); + return FromDegreesFahrenheit(degreesfahrenheit.Value); } else { @@ -244,7 +244,7 @@ public static Temperature FromKelvins(double kelvins) { if (degreesnewton.HasValue) { - return new Temperature(degreesnewton.Value*100/33 + 273.15); + return FromDegreesNewton(degreesnewton.Value); } else { @@ -259,7 +259,7 @@ public static Temperature FromKelvins(double kelvins) { if (degreesrankine.HasValue) { - return new Temperature(degreesrankine.Value*5/9); + return FromDegreesRankine(degreesrankine.Value); } else { @@ -274,7 +274,7 @@ public static Temperature FromKelvins(double kelvins) { if (degreesreaumur.HasValue) { - return new Temperature(degreesreaumur.Value*5/4 + 273.15); + return FromDegreesReaumur(degreesreaumur.Value); } else { @@ -289,7 +289,7 @@ public static Temperature FromKelvins(double kelvins) { if (degreesroemer.HasValue) { - return new Temperature(degreesroemer.Value*40/21 + 273.15 - 7.5*40d/21); + return FromDegreesRoemer(degreesroemer.Value); } else { @@ -304,7 +304,7 @@ public static Temperature FromKelvins(double kelvins) { if (kelvins.HasValue) { - return new Temperature(kelvins.Value); + return FromKelvins(kelvins.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs index a90f6bdea1..222cba5442 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs @@ -215,7 +215,7 @@ public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double nanod { if (centidegreescelsiuspersecond.HasValue) { - return new TemperatureChangeRate((centidegreescelsiuspersecond.Value) * 1e-2d); + return FromCentidegreesCelsiusPerSecond(centidegreescelsiuspersecond.Value); } else { @@ -230,7 +230,7 @@ public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double nanod { if (decadegreescelsiuspersecond.HasValue) { - return new TemperatureChangeRate((decadegreescelsiuspersecond.Value) * 1e1d); + return FromDecadegreesCelsiusPerSecond(decadegreescelsiuspersecond.Value); } else { @@ -245,7 +245,7 @@ public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double nanod { if (decidegreescelsiuspersecond.HasValue) { - return new TemperatureChangeRate((decidegreescelsiuspersecond.Value) * 1e-1d); + return FromDecidegreesCelsiusPerSecond(decidegreescelsiuspersecond.Value); } else { @@ -260,7 +260,7 @@ public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double nanod { if (degreescelsiuspersecond.HasValue) { - return new TemperatureChangeRate(degreescelsiuspersecond.Value); + return FromDegreesCelsiusPerSecond(degreescelsiuspersecond.Value); } else { @@ -275,7 +275,7 @@ public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double nanod { if (hectodegreescelsiuspersecond.HasValue) { - return new TemperatureChangeRate((hectodegreescelsiuspersecond.Value) * 1e2d); + return FromHectodegreesCelsiusPerSecond(hectodegreescelsiuspersecond.Value); } else { @@ -290,7 +290,7 @@ public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double nanod { if (kilodegreescelsiuspersecond.HasValue) { - return new TemperatureChangeRate((kilodegreescelsiuspersecond.Value) * 1e3d); + return FromKilodegreesCelsiusPerSecond(kilodegreescelsiuspersecond.Value); } else { @@ -305,7 +305,7 @@ public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double nanod { if (microdegreescelsiuspersecond.HasValue) { - return new TemperatureChangeRate((microdegreescelsiuspersecond.Value) * 1e-6d); + return FromMicrodegreesCelsiusPerSecond(microdegreescelsiuspersecond.Value); } else { @@ -320,7 +320,7 @@ public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double nanod { if (millidegreescelsiuspersecond.HasValue) { - return new TemperatureChangeRate((millidegreescelsiuspersecond.Value) * 1e-3d); + return FromMillidegreesCelsiusPerSecond(millidegreescelsiuspersecond.Value); } else { @@ -335,7 +335,7 @@ public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double nanod { if (nanodegreescelsiuspersecond.HasValue) { - return new TemperatureChangeRate((nanodegreescelsiuspersecond.Value) * 1e-9d); + return FromNanodegreesCelsiusPerSecond(nanodegreescelsiuspersecond.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs index f5c48a2363..12b641554e 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs @@ -327,7 +327,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) { if (kilogramforcecentimeters.HasValue) { - return new Torque(kilogramforcecentimeters.Value*0.0980665019960652); + return FromKilogramForceCentimeters(kilogramforcecentimeters.Value); } else { @@ -342,7 +342,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) { if (kilogramforcemeters.HasValue) { - return new Torque(kilogramforcemeters.Value*9.80665019960652); + return FromKilogramForceMeters(kilogramforcemeters.Value); } else { @@ -357,7 +357,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) { if (kilogramforcemillimeters.HasValue) { - return new Torque(kilogramforcemillimeters.Value*0.00980665019960652); + return FromKilogramForceMillimeters(kilogramforcemillimeters.Value); } else { @@ -372,7 +372,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) { if (kilonewtoncentimeters.HasValue) { - return new Torque((kilonewtoncentimeters.Value*0.01) * 1e3d); + return FromKilonewtonCentimeters(kilonewtoncentimeters.Value); } else { @@ -387,7 +387,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) { if (kilonewtonmeters.HasValue) { - return new Torque((kilonewtonmeters.Value) * 1e3d); + return FromKilonewtonMeters(kilonewtonmeters.Value); } else { @@ -402,7 +402,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) { if (kilonewtonmillimeters.HasValue) { - return new Torque((kilonewtonmillimeters.Value*0.001) * 1e3d); + return FromKilonewtonMillimeters(kilonewtonmillimeters.Value); } else { @@ -417,7 +417,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) { if (kilopoundforcefeet.HasValue) { - return new Torque((kilopoundforcefeet.Value*1.3558180656) * 1e3d); + return FromKilopoundForceFeet(kilopoundforcefeet.Value); } else { @@ -432,7 +432,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) { if (kilopoundforceinches.HasValue) { - return new Torque((kilopoundforceinches.Value*0.1129848388) * 1e3d); + return FromKilopoundForceInches(kilopoundforceinches.Value); } else { @@ -447,7 +447,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) { if (newtoncentimeters.HasValue) { - return new Torque(newtoncentimeters.Value*0.01); + return FromNewtonCentimeters(newtoncentimeters.Value); } else { @@ -462,7 +462,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) { if (newtonmeters.HasValue) { - return new Torque(newtonmeters.Value); + return FromNewtonMeters(newtonmeters.Value); } else { @@ -477,7 +477,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) { if (newtonmillimeters.HasValue) { - return new Torque(newtonmillimeters.Value*0.001); + return FromNewtonMillimeters(newtonmillimeters.Value); } else { @@ -492,7 +492,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) { if (poundforcefeet.HasValue) { - return new Torque(poundforcefeet.Value*1.3558180656); + return FromPoundForceFeet(poundforcefeet.Value); } else { @@ -507,7 +507,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) { if (poundforceinches.HasValue) { - return new Torque(poundforceinches.Value*0.1129848388); + return FromPoundForceInches(poundforceinches.Value); } else { @@ -522,7 +522,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) { if (tonneforcecentimeters.HasValue) { - return new Torque(tonneforcecentimeters.Value*98.0665019960652); + return FromTonneForceCentimeters(tonneforcecentimeters.Value); } else { @@ -537,7 +537,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) { if (tonneforcemeters.HasValue) { - return new Torque(tonneforcemeters.Value*9806.65019960653); + return FromTonneForceMeters(tonneforcemeters.Value); } else { @@ -552,7 +552,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) { if (tonneforcemillimeters.HasValue) { - return new Torque(tonneforcemillimeters.Value*9.80665019960652); + return FromTonneForceMillimeters(tonneforcemillimeters.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs b/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs index 85819dba79..6685831db2 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs @@ -87,7 +87,7 @@ public static VitaminA FromInternationalUnits(double internationalunits) { if (internationalunits.HasValue) { - return new VitaminA(internationalunits.Value); + return FromInternationalUnits(internationalunits.Value); } else { diff --git a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs index 2cd174d349..50bdeff1ca 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs @@ -537,7 +537,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (autablespoons.HasValue) { - return new Volume(autablespoons.Value*2e-5); + return FromAuTablespoons(autablespoons.Value); } else { @@ -552,7 +552,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (centiliters.HasValue) { - return new Volume((centiliters.Value/1e3) * 1e-2d); + return FromCentiliters(centiliters.Value); } else { @@ -567,7 +567,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (cubiccentimeters.HasValue) { - return new Volume(cubiccentimeters.Value/1e6); + return FromCubicCentimeters(cubiccentimeters.Value); } else { @@ -582,7 +582,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (cubicdecimeters.HasValue) { - return new Volume(cubicdecimeters.Value/1e3); + return FromCubicDecimeters(cubicdecimeters.Value); } else { @@ -597,7 +597,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (cubicfeet.HasValue) { - return new Volume(cubicfeet.Value*0.0283168); + return FromCubicFeet(cubicfeet.Value); } else { @@ -612,7 +612,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (cubicinches.HasValue) { - return new Volume(cubicinches.Value*1.6387*1e-5); + return FromCubicInches(cubicinches.Value); } else { @@ -627,7 +627,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (cubickilometers.HasValue) { - return new Volume(cubickilometers.Value*1e9); + return FromCubicKilometers(cubickilometers.Value); } else { @@ -642,7 +642,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (cubicmeters.HasValue) { - return new Volume(cubicmeters.Value); + return FromCubicMeters(cubicmeters.Value); } else { @@ -657,7 +657,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (cubicmicrometers.HasValue) { - return new Volume(cubicmicrometers.Value/1e18); + return FromCubicMicrometers(cubicmicrometers.Value); } else { @@ -672,7 +672,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (cubicmiles.HasValue) { - return new Volume(cubicmiles.Value*4.16818183*1e9); + return FromCubicMiles(cubicmiles.Value); } else { @@ -687,7 +687,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (cubicmillimeters.HasValue) { - return new Volume(cubicmillimeters.Value/1e9); + return FromCubicMillimeters(cubicmillimeters.Value); } else { @@ -702,7 +702,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (cubicyards.HasValue) { - return new Volume(cubicyards.Value*0.764554858); + return FromCubicYards(cubicyards.Value); } else { @@ -717,7 +717,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (deciliters.HasValue) { - return new Volume((deciliters.Value/1e3) * 1e-1d); + return FromDeciliters(deciliters.Value); } else { @@ -732,7 +732,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (hectoliters.HasValue) { - return new Volume((hectoliters.Value/1e3) * 1e2d); + return FromHectoliters(hectoliters.Value); } else { @@ -747,7 +747,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (imperialgallons.HasValue) { - return new Volume(imperialgallons.Value*0.00454609000000181429905810072407); + return FromImperialGallons(imperialgallons.Value); } else { @@ -762,7 +762,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (imperialounces.HasValue) { - return new Volume(imperialounces.Value*2.8413062499962901241875439064617e-5); + return FromImperialOunces(imperialounces.Value); } else { @@ -777,7 +777,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (liters.HasValue) { - return new Volume(liters.Value/1e3); + return FromLiters(liters.Value); } else { @@ -792,7 +792,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (metriccups.HasValue) { - return new Volume(metriccups.Value*0.00025); + return FromMetricCups(metriccups.Value); } else { @@ -807,7 +807,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (metricteaspoons.HasValue) { - return new Volume(metricteaspoons.Value*0.5e-5); + return FromMetricTeaspoons(metricteaspoons.Value); } else { @@ -822,7 +822,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (milliliters.HasValue) { - return new Volume((milliliters.Value/1e3) * 1e-3d); + return FromMilliliters(milliliters.Value); } else { @@ -837,7 +837,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (tablespoons.HasValue) { - return new Volume(tablespoons.Value*1.478676478125e-5); + return FromTablespoons(tablespoons.Value); } else { @@ -852,7 +852,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (teaspoons.HasValue) { - return new Volume(teaspoons.Value*4.92892159375e-6); + return FromTeaspoons(teaspoons.Value); } else { @@ -867,7 +867,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (uktablespoons.HasValue) { - return new Volume(uktablespoons.Value*1.5e-5); + return FromUkTablespoons(uktablespoons.Value); } else { @@ -882,7 +882,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (uscustomarycups.HasValue) { - return new Volume(uscustomarycups.Value*0.0002365882365); + return FromUsCustomaryCups(uscustomarycups.Value); } else { @@ -897,7 +897,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (usgallons.HasValue) { - return new Volume(usgallons.Value*0.00378541); + return FromUsGallons(usgallons.Value); } else { @@ -912,7 +912,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (uslegalcups.HasValue) { - return new Volume(uslegalcups.Value*0.00024); + return FromUsLegalCups(uslegalcups.Value); } else { @@ -927,7 +927,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (usounces.HasValue) { - return new Volume(usounces.Value*2.957352956253760505068307980135e-5); + return FromUsOunces(usounces.Value); } else { @@ -942,7 +942,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (ustablespoons.HasValue) { - return new Volume(ustablespoons.Value*1.478676478125e-5); + return FromUsTablespoons(ustablespoons.Value); } else { @@ -957,7 +957,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) { if (usteaspoons.HasValue) { - return new Volume(usteaspoons.Value*4.92892159375e-6); + return FromUsTeaspoons(usteaspoons.Value); } else { diff --git a/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 index cff747a046..19aa75fbc0 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 @@ -119,7 +119,7 @@ namespace UnitsNet { if ($($valueParamName).HasValue) { - return new $className($func); + return From$($unit.PluralName)($($valueParamName).Value); } else { From b1f549ef1ce0f01818f18063fed17584c14d44c0 Mon Sep 17 00:00:00 2001 From: Erik Ovegard Date: Tue, 1 Mar 2016 12:14:13 +0100 Subject: [PATCH 4/5] Removed generated tests and added tests in custom code based on discussion in #141 --- .../CustomCode/NullableConstructors.cs | 90 +++++++++++++ .../GeneratedCode/AccelerationTestsBase.g.cs | 30 ----- .../AmplitudeRatioTestsBase.g.cs | 30 ----- .../GeneratedCode/AngleTestsBase.g.cs | 30 ----- .../GeneratedCode/AreaTestsBase.g.cs | 30 ----- .../GeneratedCode/DensityTestsBase.g.cs | 30 ----- .../GeneratedCode/DurationTestsBase.g.cs | 30 ----- .../ElectricCurrentTestsBase.g.cs | 30 ----- .../ElectricPotentialTestsBase.g.cs | 30 ----- .../ElectricResistanceTestsBase.g.cs | 30 ----- .../GeneratedCode/EnergyTestsBase.g.cs | 30 ----- .../GeneratedCode/FlowTestsBase.g.cs | 30 ----- .../ForceChangeRateTestsBase.g.cs | 30 ----- .../GeneratedCode/ForceTestsBase.g.cs | 30 ----- .../GeneratedCode/FrequencyTestsBase.g.cs | 30 ----- .../GeneratedCode/InformationTestsBase.g.cs | 30 ----- .../KinematicViscosityTestsBase.g.cs | 30 ----- .../GeneratedCode/LengthTestsBase.g.cs | 30 ----- .../GeneratedCode/LevelTestsBase.g.cs | 30 ----- .../GeneratedCode/MassFlowTestsBase.g.cs | 30 ----- .../GeneratedCode/MassTestsBase.g.cs | 30 ----- .../GeneratedCode/PowerRatioTestsBase.g.cs | 30 ----- .../GeneratedCode/PowerTestsBase.g.cs | 30 ----- .../PressureChangeRateTestsBase.g.cs | 30 ----- .../GeneratedCode/PressureTestsBase.g.cs | 30 ----- .../GeneratedCode/RatioTestsBase.g.cs | 30 ----- .../RotationalSpeedTestsBase.g.cs | 30 ----- .../SpecificEnergyTestsBase.g.cs | 30 ----- .../SpecificWeightTestsBase.g.cs | 30 ----- .../GeneratedCode/SpeedTestsBase.g.cs | 30 ----- .../TemperatureChangeRateTestsBase.g.cs | 30 ----- .../GeneratedCode/TemperatureTestsBase.g.cs | 30 ----- .../GeneratedCode/TorqueTestsBase.g.cs | 30 ----- .../GeneratedCode/VitaminATestsBase.g.cs | 30 ----- .../GeneratedCode/VolumeTestsBase.g.cs | 30 ----- .../UnitClasses/DynamicViscosity.g.cs | 118 +++++++++++++++++- ...de-GenerateUnitTestBaseClassSourceCode.ps1 | 30 ----- 37 files changed, 202 insertions(+), 1056 deletions(-) create mode 100644 UnitsNet.Tests/CustomCode/NullableConstructors.cs diff --git a/UnitsNet.Tests/CustomCode/NullableConstructors.cs b/UnitsNet.Tests/CustomCode/NullableConstructors.cs new file mode 100644 index 0000000000..e143ed37dd --- /dev/null +++ b/UnitsNet.Tests/CustomCode/NullableConstructors.cs @@ -0,0 +1,90 @@ +// Copyright(c) 2007 Andreas Gullberg Larsen +// https://github.com/anjdreas/UnitsNet +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System; +using NUnit.Framework; +using UnitsNet.Units; + +namespace UnitsNet.Tests.CustomCode +{ + public class NullableConstructors + { + [Test] + public void StaticConstructorWithNullReturnsNullWhenBackingTypeIsDouble() + { + Length? meter = Length.FromMeters(null); + Assert.IsFalse(meter.HasValue); + } + + [Test] + public void StaticConstructorWithNullAndEnumReturnsNullWhenBackingTypeIsDouble() + { + Length? meter = Length.From(null, LengthUnit.Meter); + Assert.IsFalse(meter.HasValue); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValueWhenBackingTypeIsDouble() + { + double? value = 1.0; + Length? meter = Length.From(value, LengthUnit.Meter); + Assert.IsTrue(meter.HasValue); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValueWhenBackingTypeIsDouble() + { + double? value = 1.0; + Length? meter = Length.FromMeters(value); + Assert.IsTrue(meter.HasValue); + } + + [Test] + public void StaticConstructorWithNullReturnsNullWhenBackingTypeIsDecimal() + { + Information? meter = Information.FromBytes(null); + Assert.IsFalse(meter.HasValue); + } + + [Test] + public void StaticConstructorWithNullAndEnumReturnsNullWhenBackingTypeIsDecimal() + { + Information? meter = Information.From(null, InformationUnit.Byte); + Assert.IsFalse(meter.HasValue); + } + + [Test] + public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValueWhenBackingTypeIsDecimal() + { + double? value = 1.0; + Information? meter = Information.From(value, InformationUnit.Byte); + Assert.IsTrue(meter.HasValue); + } + + [Test] + public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValueWhenBackingTypeIsDecimal() + { + double? value = 1.0; + Information? meter = Information.FromBytes(value); + Assert.IsTrue(meter.HasValue); + } + } +} \ No newline at end of file diff --git a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs index 5e4b444891..e55a0044a4 100644 --- a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs @@ -199,35 +199,5 @@ public void EqualsReturnsFalseOnNull() Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1); Assert.IsFalse(meterpersecondsquared.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Acceleration? meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(null); - Assert.IsTrue(meterpersecondsquared.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Acceleration? meterpersecondsquared = Acceleration.From(null,AccelerationUnit.MeterPerSecondSquared); - Assert.IsTrue(meterpersecondsquared.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Acceleration? meterpersecondsquared = Acceleration.From(value,AccelerationUnit.MeterPerSecondSquared); - Assert.IsTrue(meterpersecondsquared.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Acceleration? meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(value); - Assert.IsTrue(meterpersecondsquared.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs index f1212fe2e1..786dcee38d 100644 --- a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs @@ -179,35 +179,5 @@ public void EqualsReturnsFalseOnNull() AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1); Assert.IsFalse(decibelvolt.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - AmplitudeRatio? decibelvolt = AmplitudeRatio.FromDecibelVolts(null); - Assert.IsTrue(decibelvolt.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - AmplitudeRatio? decibelvolt = AmplitudeRatio.From(null,AmplitudeRatioUnit.DecibelVolt); - Assert.IsTrue(decibelvolt.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - AmplitudeRatio? decibelvolt = AmplitudeRatio.From(value,AmplitudeRatioUnit.DecibelVolt); - Assert.IsTrue(decibelvolt.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - AmplitudeRatio? decibelvolt = AmplitudeRatio.FromDecibelVolts(value); - Assert.IsTrue(decibelvolt.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs index 35132cf429..d330008fcc 100644 --- a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs @@ -217,35 +217,5 @@ public void EqualsReturnsFalseOnNull() Angle degree = Angle.FromDegrees(1); Assert.IsFalse(degree.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Angle? degree = Angle.FromDegrees(null); - Assert.IsTrue(degree.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Angle? degree = Angle.From(null,AngleUnit.Degree); - Assert.IsTrue(degree.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Angle? degree = Angle.From(value,AngleUnit.Degree); - Assert.IsTrue(degree.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Angle? degree = Angle.FromDegrees(value); - Assert.IsTrue(degree.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs index 343b4d4d54..ada71764bf 100644 --- a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs @@ -217,35 +217,5 @@ public void EqualsReturnsFalseOnNull() Area squaremeter = Area.FromSquareMeters(1); Assert.IsFalse(squaremeter.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Area? squaremeter = Area.FromSquareMeters(null); - Assert.IsTrue(squaremeter.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Area? squaremeter = Area.From(null,AreaUnit.SquareMeter); - Assert.IsTrue(squaremeter.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Area? squaremeter = Area.From(value,AreaUnit.SquareMeter); - Assert.IsTrue(squaremeter.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Area? squaremeter = Area.FromSquareMeters(value); - Assert.IsTrue(squaremeter.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs index 85c69e5c3c..87a39ad9c6 100644 --- a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs @@ -217,35 +217,5 @@ public void EqualsReturnsFalseOnNull() Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1); Assert.IsFalse(kilogrampercubicmeter.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Density? kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(null); - Assert.IsTrue(kilogrampercubicmeter.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Density? kilogrampercubicmeter = Density.From(null,DensityUnit.KilogramPerCubicMeter); - Assert.IsTrue(kilogrampercubicmeter.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Density? kilogrampercubicmeter = Density.From(value,DensityUnit.KilogramPerCubicMeter); - Assert.IsTrue(kilogrampercubicmeter.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Density? kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(value); - Assert.IsTrue(kilogrampercubicmeter.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs index 79328746ce..3b134a6b08 100644 --- a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs @@ -217,35 +217,5 @@ public void EqualsReturnsFalseOnNull() Duration second = Duration.FromSeconds(1); Assert.IsFalse(second.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Duration? second = Duration.FromSeconds(null); - Assert.IsTrue(second.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Duration? second = Duration.From(null,DurationUnit.Second); - Assert.IsTrue(second.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Duration? second = Duration.From(value,DurationUnit.Second); - Assert.IsTrue(second.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Duration? second = Duration.FromSeconds(value); - Assert.IsTrue(second.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs index ac377769f4..52f03bd23f 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs @@ -193,35 +193,5 @@ public void EqualsReturnsFalseOnNull() ElectricCurrent ampere = ElectricCurrent.FromAmperes(1); Assert.IsFalse(ampere.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - ElectricCurrent? ampere = ElectricCurrent.FromAmperes(null); - Assert.IsTrue(ampere.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - ElectricCurrent? ampere = ElectricCurrent.From(null,ElectricCurrentUnit.Ampere); - Assert.IsTrue(ampere.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - ElectricCurrent? ampere = ElectricCurrent.From(value,ElectricCurrentUnit.Ampere); - Assert.IsTrue(ampere.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - ElectricCurrent? ampere = ElectricCurrent.FromAmperes(value); - Assert.IsTrue(ampere.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs index 93aac20ece..319f56cacc 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs @@ -187,35 +187,5 @@ public void EqualsReturnsFalseOnNull() ElectricPotential volt = ElectricPotential.FromVolts(1); Assert.IsFalse(volt.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - ElectricPotential? volt = ElectricPotential.FromVolts(null); - Assert.IsTrue(volt.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - ElectricPotential? volt = ElectricPotential.From(null,ElectricPotentialUnit.Volt); - Assert.IsTrue(volt.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - ElectricPotential? volt = ElectricPotential.From(value,ElectricPotentialUnit.Volt); - Assert.IsTrue(volt.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - ElectricPotential? volt = ElectricPotential.FromVolts(value); - Assert.IsTrue(volt.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs index 50707a586d..a23d9028c1 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs @@ -175,35 +175,5 @@ public void EqualsReturnsFalseOnNull() ElectricResistance ohm = ElectricResistance.FromOhms(1); Assert.IsFalse(ohm.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - ElectricResistance? ohm = ElectricResistance.FromOhms(null); - Assert.IsTrue(ohm.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - ElectricResistance? ohm = ElectricResistance.From(null,ElectricResistanceUnit.Ohm); - Assert.IsTrue(ohm.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - ElectricResistance? ohm = ElectricResistance.From(value,ElectricResistanceUnit.Ohm); - Assert.IsTrue(ohm.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - ElectricResistance? ohm = ElectricResistance.FromOhms(value); - Assert.IsTrue(ohm.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs index f38fc3f74b..e23f86a521 100644 --- a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs @@ -235,35 +235,5 @@ public void EqualsReturnsFalseOnNull() Energy joule = Energy.FromJoules(1); Assert.IsFalse(joule.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Energy? joule = Energy.FromJoules(null); - Assert.IsTrue(joule.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Energy? joule = Energy.From(null,EnergyUnit.Joule); - Assert.IsTrue(joule.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Energy? joule = Energy.From(value,EnergyUnit.Joule); - Assert.IsTrue(joule.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Energy? joule = Energy.FromJoules(value); - Assert.IsTrue(joule.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs index 257bb0cf4c..8287346863 100644 --- a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs @@ -193,35 +193,5 @@ public void EqualsReturnsFalseOnNull() Flow cubicmeterpersecond = Flow.FromCubicMetersPerSecond(1); Assert.IsFalse(cubicmeterpersecond.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Flow? cubicmeterpersecond = Flow.FromCubicMetersPerSecond(null); - Assert.IsTrue(cubicmeterpersecond.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Flow? cubicmeterpersecond = Flow.From(null,FlowUnit.CubicMeterPerSecond); - Assert.IsTrue(cubicmeterpersecond.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Flow? cubicmeterpersecond = Flow.From(value,FlowUnit.CubicMeterPerSecond); - Assert.IsTrue(cubicmeterpersecond.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Flow? cubicmeterpersecond = Flow.FromCubicMetersPerSecond(value); - Assert.IsTrue(cubicmeterpersecond.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs index c6e28b48e0..c521f78f26 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs @@ -163,35 +163,5 @@ public void EqualsReturnsFalseOnNull() ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1); Assert.IsFalse(newtonpersecond.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - ForceChangeRate? newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(null); - Assert.IsTrue(newtonpersecond.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - ForceChangeRate? newtonpersecond = ForceChangeRate.From(null,ForceChangeRateUnit.NewtonPerSecond); - Assert.IsTrue(newtonpersecond.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - ForceChangeRate? newtonpersecond = ForceChangeRate.From(value,ForceChangeRateUnit.NewtonPerSecond); - Assert.IsTrue(newtonpersecond.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - ForceChangeRate? newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(value); - Assert.IsTrue(newtonpersecond.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs index afbce616a8..94a60dbe77 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs @@ -205,35 +205,5 @@ public void EqualsReturnsFalseOnNull() Force newton = Force.FromNewtons(1); Assert.IsFalse(newton.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Force? newton = Force.FromNewtons(null); - Assert.IsTrue(newton.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Force? newton = Force.From(null,ForceUnit.Newton); - Assert.IsTrue(newton.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Force? newton = Force.From(value,ForceUnit.Newton); - Assert.IsTrue(newton.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Force? newton = Force.FromNewtons(value); - Assert.IsTrue(newton.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs index d8dee4f3ae..c01b961863 100644 --- a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs @@ -205,35 +205,5 @@ public void EqualsReturnsFalseOnNull() Frequency hertz = Frequency.FromHertz(1); Assert.IsFalse(hertz.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Frequency? hertz = Frequency.FromHertz(null); - Assert.IsTrue(hertz.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Frequency? hertz = Frequency.From(null,FrequencyUnit.Hertz); - Assert.IsTrue(hertz.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Frequency? hertz = Frequency.From(value,FrequencyUnit.Hertz); - Assert.IsTrue(hertz.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Frequency? hertz = Frequency.FromHertz(value); - Assert.IsTrue(hertz.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs index e50d3e5272..f740691f61 100644 --- a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs @@ -313,35 +313,5 @@ public void EqualsReturnsFalseOnNull() Information bit = Information.FromBits(1); Assert.IsFalse(bit.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Information? bit = Information.FromBits(null); - Assert.IsTrue(bit.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Information? bit = Information.From(null,InformationUnit.Bit); - Assert.IsTrue(bit.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Information? bit = Information.From(value,InformationUnit.Bit); - Assert.IsTrue(bit.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Information? bit = Information.FromBits(value); - Assert.IsTrue(bit.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs index 0a870f80f3..b22eb12e06 100644 --- a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs @@ -205,35 +205,5 @@ public void EqualsReturnsFalseOnNull() KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1); Assert.IsFalse(squaremeterpersecond.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - KinematicViscosity? squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(null); - Assert.IsTrue(squaremeterpersecond.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - KinematicViscosity? squaremeterpersecond = KinematicViscosity.From(null,KinematicViscosityUnit.SquareMeterPerSecond); - Assert.IsTrue(squaremeterpersecond.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - KinematicViscosity? squaremeterpersecond = KinematicViscosity.From(value,KinematicViscosityUnit.SquareMeterPerSecond); - Assert.IsTrue(squaremeterpersecond.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - KinematicViscosity? squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(value); - Assert.IsTrue(squaremeterpersecond.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs index 7c983435ee..a247b5798b 100644 --- a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs @@ -241,35 +241,5 @@ public void EqualsReturnsFalseOnNull() Length meter = Length.FromMeters(1); Assert.IsFalse(meter.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Length? meter = Length.FromMeters(null); - Assert.IsTrue(meter.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Length? meter = Length.From(null,LengthUnit.Meter); - Assert.IsTrue(meter.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Length? meter = Length.From(value,LengthUnit.Meter); - Assert.IsTrue(meter.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Length? meter = Length.FromMeters(value); - Assert.IsTrue(meter.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs index 4576c183bd..dac295d95d 100644 --- a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs @@ -173,35 +173,5 @@ public void EqualsReturnsFalseOnNull() Level decibel = Level.FromDecibels(1); Assert.IsFalse(decibel.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Level? decibel = Level.FromDecibels(null); - Assert.IsTrue(decibel.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Level? decibel = Level.From(null,LevelUnit.Decibel); - Assert.IsTrue(decibel.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Level? decibel = Level.From(value,LevelUnit.Decibel); - Assert.IsTrue(decibel.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Level? decibel = Level.FromDecibels(value); - Assert.IsTrue(decibel.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs index ff21eed02e..583c7cf5dc 100644 --- a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs @@ -217,35 +217,5 @@ public void EqualsReturnsFalseOnNull() MassFlow grampersecond = MassFlow.FromGramsPerSecond(1); Assert.IsFalse(grampersecond.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - MassFlow? grampersecond = MassFlow.FromGramsPerSecond(null); - Assert.IsTrue(grampersecond.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - MassFlow? grampersecond = MassFlow.From(null,MassFlowUnit.GramPerSecond); - Assert.IsTrue(grampersecond.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - MassFlow? grampersecond = MassFlow.From(value,MassFlowUnit.GramPerSecond); - Assert.IsTrue(grampersecond.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - MassFlow? grampersecond = MassFlow.FromGramsPerSecond(value); - Assert.IsTrue(grampersecond.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs index 8b0d947352..7775d245e0 100644 --- a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs @@ -259,35 +259,5 @@ public void EqualsReturnsFalseOnNull() Mass kilogram = Mass.FromKilograms(1); Assert.IsFalse(kilogram.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Mass? kilogram = Mass.FromKilograms(null); - Assert.IsTrue(kilogram.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Mass? kilogram = Mass.From(null,MassUnit.Kilogram); - Assert.IsTrue(kilogram.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Mass? kilogram = Mass.From(value,MassUnit.Kilogram); - Assert.IsTrue(kilogram.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Mass? kilogram = Mass.FromKilograms(value); - Assert.IsTrue(kilogram.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs index b58a57d61d..4c505d6c08 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs @@ -173,35 +173,5 @@ public void EqualsReturnsFalseOnNull() PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1); Assert.IsFalse(decibelwatt.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - PowerRatio? decibelwatt = PowerRatio.FromDecibelWatts(null); - Assert.IsTrue(decibelwatt.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - PowerRatio? decibelwatt = PowerRatio.From(null,PowerRatioUnit.DecibelWatt); - Assert.IsTrue(decibelwatt.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - PowerRatio? decibelwatt = PowerRatio.From(value,PowerRatioUnit.DecibelWatt); - Assert.IsTrue(decibelwatt.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - PowerRatio? decibelwatt = PowerRatio.FromDecibelWatts(value); - Assert.IsTrue(decibelwatt.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs index 00d2d79ea6..221ceaf04f 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs @@ -253,35 +253,5 @@ public void EqualsReturnsFalseOnNull() Power watt = Power.FromWatts(1); Assert.IsFalse(watt.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Power? watt = Power.FromWatts(null); - Assert.IsTrue(watt.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Power? watt = Power.From(null,PowerUnit.Watt); - Assert.IsTrue(watt.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Power? watt = Power.From(value,PowerUnit.Watt); - Assert.IsTrue(watt.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Power? watt = Power.FromWatts(value); - Assert.IsTrue(watt.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs index c6964efe33..f9200bb56a 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs @@ -181,35 +181,5 @@ public void EqualsReturnsFalseOnNull() PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1); Assert.IsFalse(pascalpersecond.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - PressureChangeRate? pascalpersecond = PressureChangeRate.FromPascalsPerSecond(null); - Assert.IsTrue(pascalpersecond.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - PressureChangeRate? pascalpersecond = PressureChangeRate.From(null,PressureChangeRateUnit.PascalPerSecond); - Assert.IsTrue(pascalpersecond.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - PressureChangeRate? pascalpersecond = PressureChangeRate.From(value,PressureChangeRateUnit.PascalPerSecond); - Assert.IsTrue(pascalpersecond.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - PressureChangeRate? pascalpersecond = PressureChangeRate.FromPascalsPerSecond(value); - Assert.IsTrue(pascalpersecond.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs index a8c637fb79..cf3b489a71 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs @@ -355,35 +355,5 @@ public void EqualsReturnsFalseOnNull() Pressure pascal = Pressure.FromPascals(1); Assert.IsFalse(pascal.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Pressure? pascal = Pressure.FromPascals(null); - Assert.IsTrue(pascal.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Pressure? pascal = Pressure.From(null,PressureUnit.Pascal); - Assert.IsTrue(pascal.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Pressure? pascal = Pressure.From(value,PressureUnit.Pascal); - Assert.IsTrue(pascal.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Pressure? pascal = Pressure.FromPascals(value); - Assert.IsTrue(pascal.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs index 689cf58566..212682834e 100644 --- a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs @@ -193,35 +193,5 @@ public void EqualsReturnsFalseOnNull() Ratio decimalfraction = Ratio.FromDecimalFractions(1); Assert.IsFalse(decimalfraction.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Ratio? decimalfraction = Ratio.FromDecimalFractions(null); - Assert.IsTrue(decimalfraction.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Ratio? decimalfraction = Ratio.From(null,RatioUnit.DecimalFraction); - Assert.IsTrue(decimalfraction.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Ratio? decimalfraction = Ratio.From(value,RatioUnit.DecimalFraction); - Assert.IsTrue(decimalfraction.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Ratio? decimalfraction = Ratio.FromDecimalFractions(value); - Assert.IsTrue(decimalfraction.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs index 4134e619f8..552412d898 100644 --- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs @@ -205,35 +205,5 @@ public void EqualsReturnsFalseOnNull() RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); Assert.IsFalse(radianpersecond.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - RotationalSpeed? radianpersecond = RotationalSpeed.FromRadiansPerSecond(null); - Assert.IsTrue(radianpersecond.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - RotationalSpeed? radianpersecond = RotationalSpeed.From(null,RotationalSpeedUnit.RadianPerSecond); - Assert.IsTrue(radianpersecond.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - RotationalSpeed? radianpersecond = RotationalSpeed.From(value,RotationalSpeedUnit.RadianPerSecond); - Assert.IsTrue(radianpersecond.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - RotationalSpeed? radianpersecond = RotationalSpeed.FromRadiansPerSecond(value); - Assert.IsTrue(radianpersecond.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs index ddd6854406..7a5ba37b27 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs @@ -205,35 +205,5 @@ public void EqualsReturnsFalseOnNull() SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1); Assert.IsFalse(jouleperkilogram.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - SpecificEnergy? jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(null); - Assert.IsTrue(jouleperkilogram.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - SpecificEnergy? jouleperkilogram = SpecificEnergy.From(null,SpecificEnergyUnit.JoulePerKilogram); - Assert.IsTrue(jouleperkilogram.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - SpecificEnergy? jouleperkilogram = SpecificEnergy.From(value,SpecificEnergyUnit.JoulePerKilogram); - Assert.IsTrue(jouleperkilogram.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - SpecificEnergy? jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(value); - Assert.IsTrue(jouleperkilogram.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs index f365d11f1f..52535a75d2 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs @@ -253,35 +253,5 @@ public void EqualsReturnsFalseOnNull() SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1); Assert.IsFalse(newtonpercubicmeter.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - SpecificWeight? newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(null); - Assert.IsTrue(newtonpercubicmeter.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - SpecificWeight? newtonpercubicmeter = SpecificWeight.From(null,SpecificWeightUnit.NewtonPerCubicMeter); - Assert.IsTrue(newtonpercubicmeter.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - SpecificWeight? newtonpercubicmeter = SpecificWeight.From(value,SpecificWeightUnit.NewtonPerCubicMeter); - Assert.IsTrue(newtonpercubicmeter.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - SpecificWeight? newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(value); - Assert.IsTrue(newtonpercubicmeter.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs index fc39cf0a3c..c87c6c8bb8 100644 --- a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs @@ -229,35 +229,5 @@ public void EqualsReturnsFalseOnNull() Speed meterpersecond = Speed.FromMetersPerSecond(1); Assert.IsFalse(meterpersecond.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Speed? meterpersecond = Speed.FromMetersPerSecond(null); - Assert.IsTrue(meterpersecond.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Speed? meterpersecond = Speed.From(null,SpeedUnit.MeterPerSecond); - Assert.IsTrue(meterpersecond.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Speed? meterpersecond = Speed.From(value,SpeedUnit.MeterPerSecond); - Assert.IsTrue(meterpersecond.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Speed? meterpersecond = Speed.FromMetersPerSecond(value); - Assert.IsTrue(meterpersecond.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs index e14c292804..e5b1a8daf6 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs @@ -211,35 +211,5 @@ public void EqualsReturnsFalseOnNull() TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1); Assert.IsFalse(degreecelsiuspersecond.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - TemperatureChangeRate? degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(null); - Assert.IsTrue(degreecelsiuspersecond.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - TemperatureChangeRate? degreecelsiuspersecond = TemperatureChangeRate.From(null,TemperatureChangeRateUnit.DegreeCelsiusPerSecond); - Assert.IsTrue(degreecelsiuspersecond.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - TemperatureChangeRate? degreecelsiuspersecond = TemperatureChangeRate.From(value,TemperatureChangeRateUnit.DegreeCelsiusPerSecond); - Assert.IsTrue(degreecelsiuspersecond.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - TemperatureChangeRate? degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(value); - Assert.IsTrue(degreecelsiuspersecond.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs index 79ee5738ee..874ea01916 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs @@ -205,35 +205,5 @@ public void EqualsReturnsFalseOnNull() Temperature kelvin = Temperature.FromKelvins(1); Assert.IsFalse(kelvin.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Temperature? kelvin = Temperature.FromKelvins(null); - Assert.IsTrue(kelvin.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Temperature? kelvin = Temperature.From(null,TemperatureUnit.Kelvin); - Assert.IsTrue(kelvin.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Temperature? kelvin = Temperature.From(value,TemperatureUnit.Kelvin); - Assert.IsTrue(kelvin.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Temperature? kelvin = Temperature.FromKelvins(value); - Assert.IsTrue(kelvin.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs index 6c74acf5ce..8b7469ba75 100644 --- a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs @@ -253,35 +253,5 @@ public void EqualsReturnsFalseOnNull() Torque newtonmeter = Torque.FromNewtonMeters(1); Assert.IsFalse(newtonmeter.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Torque? newtonmeter = Torque.FromNewtonMeters(null); - Assert.IsTrue(newtonmeter.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Torque? newtonmeter = Torque.From(null,TorqueUnit.NewtonMeter); - Assert.IsTrue(newtonmeter.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Torque? newtonmeter = Torque.From(value,TorqueUnit.NewtonMeter); - Assert.IsTrue(newtonmeter.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Torque? newtonmeter = Torque.FromNewtonMeters(value); - Assert.IsTrue(newtonmeter.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs index ba02b17ec9..f6c0f92814 100644 --- a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs @@ -163,35 +163,5 @@ public void EqualsReturnsFalseOnNull() VitaminA internationalunit = VitaminA.FromInternationalUnits(1); Assert.IsFalse(internationalunit.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - VitaminA? internationalunit = VitaminA.FromInternationalUnits(null); - Assert.IsTrue(internationalunit.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - VitaminA? internationalunit = VitaminA.From(null,VitaminAUnit.InternationalUnit); - Assert.IsTrue(internationalunit.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - VitaminA? internationalunit = VitaminA.From(value,VitaminAUnit.InternationalUnit); - Assert.IsTrue(internationalunit.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - VitaminA? internationalunit = VitaminA.FromInternationalUnits(value); - Assert.IsTrue(internationalunit.HasValue); - } } } diff --git a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs index 09a90208da..35297ebd61 100644 --- a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs @@ -331,35 +331,5 @@ public void EqualsReturnsFalseOnNull() Volume cubicmeter = Volume.FromCubicMeters(1); Assert.IsFalse(cubicmeter.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - Volume? cubicmeter = Volume.FromCubicMeters(null); - Assert.IsTrue(cubicmeter.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - Volume? cubicmeter = Volume.From(null,VolumeUnit.CubicMeter); - Assert.IsTrue(cubicmeter.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Volume? cubicmeter = Volume.From(value,VolumeUnit.CubicMeter); - Assert.IsTrue(cubicmeter.HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - Volume? cubicmeter = Volume.FromCubicMeters(value); - Assert.IsTrue(cubicmeter.HasValue); - } } } diff --git a/UnitsNet/GeneratedCode/UnitClasses/DynamicViscosity.g.cs b/UnitsNet/GeneratedCode/UnitClasses/DynamicViscosity.g.cs index e64dcbc49b..20b001055a 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/DynamicViscosity.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/DynamicViscosity.g.cs @@ -144,6 +144,82 @@ public static DynamicViscosity FromPoise(double poise) } + /// + /// Get nullable DynamicViscosity from nullable Centipoise. + /// + public static DynamicViscosity? FromCentipoise(double? centipoise) + { + if (centipoise.HasValue) + { + return FromCentipoise(centipoise.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable DynamicViscosity from nullable MillipascalSeconds. + /// + public static DynamicViscosity? FromMillipascalSeconds(double? millipascalseconds) + { + if (millipascalseconds.HasValue) + { + return FromMillipascalSeconds(millipascalseconds.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable DynamicViscosity from nullable NewtonSecondsPerMeterSquared. + /// + public static DynamicViscosity? FromNewtonSecondsPerMeterSquared(double? newtonsecondspermetersquared) + { + if (newtonsecondspermetersquared.HasValue) + { + return FromNewtonSecondsPerMeterSquared(newtonsecondspermetersquared.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable DynamicViscosity from nullable PascalSeconds. + /// + public static DynamicViscosity? FromPascalSeconds(double? pascalseconds) + { + if (pascalseconds.HasValue) + { + return FromPascalSeconds(pascalseconds.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable DynamicViscosity from nullable Poise. + /// + public static DynamicViscosity? FromPoise(double? poise) + { + if (poise.HasValue) + { + return FromPoise(poise.Value); + } + else + { + return null; + } + } + + /// /// Dynamically convert from value and unit enum to . /// @@ -170,6 +246,36 @@ public static DynamicViscosity From(double value, DynamicViscosityUnit fromUnit) } } + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// DynamicViscosity unit value. + public static DynamicViscosity? From(double? value, DynamicViscosityUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case DynamicViscosityUnit.Centipoise: + return FromCentipoise(value.Value); + case DynamicViscosityUnit.MillipascalSecond: + return FromMillipascalSeconds(value.Value); + case DynamicViscosityUnit.NewtonSecondPerMeterSquared: + return FromNewtonSecondsPerMeterSquared(value.Value); + case DynamicViscosityUnit.PascalSecond: + return FromPascalSeconds(value.Value); + case DynamicViscosityUnit.Poise: + return FromPoise(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + /// /// Get unit abbreviation string. /// @@ -331,14 +437,14 @@ public double As(DynamicViscosityUnit unit) /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" /// /// - /// More than one unit is represented by the specified unit abbreviation. - /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of - /// , and . + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . /// /// - /// If anything else goes wrong, typically due to a bug or unhandled case. - /// We wrap exceptions in to allow you to distinguish - /// Units.NET exceptions from other exceptions. + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. /// public static DynamicViscosity Parse(string str, IFormatProvider formatProvider = null) { diff --git a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 index 20e6f86ac9..3eadcdfb21 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 @@ -194,36 +194,6 @@ namespace UnitsNet.Tests $className $baseUnitVariableName = $className.From$baseUnitPluralName(1); Assert.IsFalse($baseUnitVariableName.Equals(null)); } - - [Test] - public void StaticConstructorWithNullReturnsNull() - { - $($className)? $baseUnitVariableName = $className.From$baseUnitPluralName(null); - Assert.IsTrue($baseUnitVariableName.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumReturnsNull() - { - $($className)? $baseUnitVariableName = $className.From(null,$($unitEnumName).$($baseUnit.SingularName)); - Assert.IsTrue($baseUnitVariableName.Equals(null)); - } - - [Test] - public void StaticConstructorWithNullAndEnumArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - $($className)? $baseUnitVariableName = $className.From(value,$($unitEnumName).$($baseUnit.SingularName)); - Assert.IsTrue($($baseUnitVariableName).HasValue); - } - - [Test] - public void StaticConstructorWithNullArgumentReturnsValueWhenInputArgumentHasValue() - { - double? value = 1.0; - $($className)? $baseUnitVariableName = $className.From$baseUnitPluralName(value); - Assert.IsTrue($($baseUnitVariableName).HasValue); - } } } "@; From 421a8eb5a78d3498de4ae17d506414023fb61023 Mon Sep 17 00:00:00 2001 From: Erik Ovegard Date: Tue, 1 Mar 2016 13:07:19 +0100 Subject: [PATCH 5/5] Moved "NullableConstructors.cs" --- UnitsNet.Tests/{CustomCode => }/NullableConstructors.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename UnitsNet.Tests/{CustomCode => }/NullableConstructors.cs (98%) diff --git a/UnitsNet.Tests/CustomCode/NullableConstructors.cs b/UnitsNet.Tests/NullableConstructors.cs similarity index 98% rename from UnitsNet.Tests/CustomCode/NullableConstructors.cs rename to UnitsNet.Tests/NullableConstructors.cs index e143ed37dd..85a725b922 100644 --- a/UnitsNet.Tests/CustomCode/NullableConstructors.cs +++ b/UnitsNet.Tests/NullableConstructors.cs @@ -23,7 +23,7 @@ using NUnit.Framework; using UnitsNet.Units; -namespace UnitsNet.Tests.CustomCode +namespace UnitsNet.Tests { public class NullableConstructors {