Implicit cast between Duration and TimeSpan (#1365)

### Changes
- Change `Duration` from explicit to implicit cast to/from `TimeSpan`
- Remove operator overloads for `TimeSpan` now covered by implicit cast for all but left operands

### Background
See #1354 (comment)

One issue is that the operator overloads only work when `TimeSpan` is the right operand.

I changed the code generation to take this into account, but another option would be to make a breaking change where we just don't support `TimeSpan` as the left operand at all.

Then users would have to cast explicitly, or for multiplication just reverse the operands.

This would affect 13 operators:

```
TimeSpan * Acceleration
TimeSpan * ElectricCurrent
TimeSpan * ElectricCurrentGradient
TimeSpan * ForceChangeRate
TimeSpan * KinematicViscosity
TimeSpan * MassFlow
TimeSpan * MolarFlow
TimeSpan * Power
TimeSpan * PressureChangeRate
TimeSpan * RotationalSpeed
TimeSpan * Speed
TimeSpan * TemperatureChangeRate
TimeSpan * VolumeFlow
```

Of which only 6 are used in tests so I assume are supported in v5:
```
TimeSpan * KinematicViscosity
TimeSpan * MassFlow
TimeSpan * Power
TimeSpan * RotationalSpeed
TimeSpan * TemperatureChangeRate
TimeSpan * Speed
```

---------

Co-authored-by: Andreas Gullberg Larsen <andreas.larsen84@gmail.com>

CodeGen/Generators/QuantityRelationsParser.cs

@@ -59,17 +59,6 @@ public static void ParseAndApplyRelations(string rootDir, Quantity[] quantities)
                 })
                 .ToList());
 
-            // We can infer TimeSpan relations from Duration relations.
-            var timeSpanQuantity = pseudoQuantity with { Name = "TimeSpan" };
-            relations.AddRange(relations
-                .Where(r => r.LeftQuantity.Name is "Duration")
-                .Select(r => r with { LeftQuantity = timeSpanQuantity })
-                .ToList());
-            relations.AddRange(relations
-                .Where(r => r.RightQuantity.Name is "Duration")
-                .Select(r => r with { RightQuantity = timeSpanQuantity })
-                .ToList());
-
             // Sort all relations to keep generated operators in a consistent order.
             relations.Sort();
 
@@ -96,9 +85,9 @@ public static void ParseAndApplyRelations(string rootDir, Quantity[] quantities)
                         // The left operand of a relation is responsible for generating the operator.
                         quantityRelations.Add(relation);
                     }
-                    else if (relation.RightQuantity == quantity && relation.LeftQuantity.Name is "double" or "TimeSpan")
+                    else if (relation.RightQuantity == quantity && relation.LeftQuantity.Name is "double")
                     {
-                        // Because we cannot add generated operators to double or TimeSpan, we make the right operand responsible in this case.
+                        // Because we cannot add operators to double we make the right operand responsible in this case.
                         quantityRelations.Add(relation);
                     }
                 }

CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs

@@ -746,16 +746,6 @@ private void GenerateRelationalOperators()
                     var rightParameter = relation.RightQuantity.Name.ToCamelCase();
                     var rightConversionProperty = relation.RightUnit.PluralName;
 
-                    if (relation.LeftQuantity.Name is nameof(TimeSpan))
-                    {
-                        leftConversionProperty = "Total" + leftConversionProperty;
-                    }
-
-                    if (relation.RightQuantity.Name is nameof(TimeSpan))
-                    {
-                        rightConversionProperty = "Total" + rightConversionProperty;
-                    }
-
                     if (leftParameter == rightParameter)
                     {
                         leftParameter = "left";

UnitsNet.Tests/CustomCode/KinematicViscosityTests.cs

@@ -56,13 +56,6 @@ public static void KinematicViscosityTimesTimeSpanEqualsArea()
             Assert.Equal(area, Area.FromSquareMeters(8));
         }
 
-        [Fact]
-        public static void TimeSpanTimesKinematicViscosityEqualsArea()
-        {
-            Area area = TimeSpan.FromSeconds(2)*KinematicViscosity.FromSquareMetersPerSecond(4);
-            Assert.Equal(area, Area.FromSquareMeters(8));
-        }
-
         [Fact]
         public static void KinematicViscosityTimesDensityEqualsDynamicViscosity()
         {

UnitsNet.Tests/CustomCode/MassFlowTests.cs

@@ -97,13 +97,6 @@ public void MassFlowTimesTimeSpanEqualsMass()
             Assert.Equal(mass, Mass.FromKilograms(80.0));
         }
 
-        [Fact]
-        public void TimeSpanTimesMassFlowEqualsMass()
-        {
-            Mass mass = TimeSpan.FromSeconds(4.0) * MassFlow.FromKilogramsPerSecond(20.0);
-            Assert.Equal(mass, Mass.FromKilograms(80.0));
-        }
-
         [Fact]
         public void MassFlowDividedByBrakeSpecificFuelConsumptionEqualsPower()
         {

UnitsNet.Tests/CustomCode/PowerTests.cs

@@ -104,13 +104,6 @@ public void PowerTimesTimeSpanEqualsEnergy()
             Assert.Equal(energy, Energy.FromJoules(40.0));
         }
 
-        [Fact]
-        public void TimeSpanTimesPowerEqualsEnergy()
-        {
-            Energy energy = TimeSpan.FromSeconds(8.0) * Power.FromWatts(5.0);
-            Assert.Equal(energy, Energy.FromJoules(40.0));
-        }
-
         [Fact]
         public void PowerTimesBrakeSpecificFuelConsumptionEqualsMassFlow()
         {

UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs

@@ -55,12 +55,5 @@ public void RotationalSpeedTimesTimeSpanEqualsAngle()
             Angle angle = RotationalSpeed.FromRadiansPerSecond(10.0)*TimeSpan.FromSeconds(9.0);
             Assert.Equal(angle, Angle.FromRadians(90.0));
         }
-
-        [Fact]
-        public void TimeSpanTimesRotationalSpeedEqualsAngle()
-        {
-            Angle angle = TimeSpan.FromSeconds(9.0)*RotationalSpeed.FromRadiansPerSecond(10.0);
-            Assert.Equal(angle, Angle.FromRadians(90.0));
-        }
     }
 }

UnitsNet.Tests/CustomCode/SpeedTests.cs

@@ -131,13 +131,6 @@ public void SpeedTimesTimeSpanEqualsLength()
             Assert.Equal(length, Length.FromMeters(40));
         }
 
-        [Fact]
-        public void TimeSpanTimesSpeedEqualsLength()
-        {
-            Length length = TimeSpan.FromSeconds(2)*Speed.FromMetersPerSecond(20);
-            Assert.Equal(length, Length.FromMeters(40));
-        }
-
         [Fact]
         public void SpeedTimesLengthEqualsKinematicViscosity()
         {

UnitsNet.Tests/CustomCode/TemperatureChangeRateTests.cs

@@ -36,13 +36,6 @@ public void TemperatureChangeRateMultipliedWithTimeSpanEqualsTemperatureDelta()
             Assert.Equal(TemperatureDelta.FromDegreesCelsius(20), d);
         }
 
-        [Fact]
-        public void TimeSpanMultipliedWithTemperatureChangeRateEqualsTemperatureDelta()
-        {
-            TemperatureDelta d = new TimeSpan(0, 0, -10) * TemperatureChangeRate.FromDegreesCelsiusPerSecond(2);
-            Assert.Equal(TemperatureDelta.FromDegreesCelsius(-20), d);
-        }
-
         [Fact]
         public void TemperatureChangeRateMultipliedWithDurationEqualsTemperatureDelta()
         {

UnitsNet/CustomCode/Quantities/Duration.extra.cs

@@ -11,13 +11,19 @@ public partial struct Duration
         /// <summary>
         ///     Convert a Duration to a TimeSpan.
         /// </summary>
-        /// <exception cref="ArgumentOutOfRangeException">Throws if the TimeSpan can't represent the Duration exactly </exception>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///     Throws if the duration exceeds the <see cref="TimeSpan"/>.<see cref="TimeSpan.MaxValue"/> or
+        ///     <see cref="TimeSpan.MinValue"/>, which would cause it to roll over from positive to negative and vice versa.
+        /// </exception>
         /// <returns>The TimeSpan with the same time as the duration</returns>
         public TimeSpan ToTimeSpan()
         {
-            if ( Seconds > TimeSpan.MaxValue.TotalSeconds ||
-                Seconds < TimeSpan.MinValue.TotalSeconds )
-                throw new ArgumentOutOfRangeException( nameof( Duration ), "The duration is too large or small to fit in a TimeSpan" );
+            if (Seconds > TimeSpan.MaxValue.TotalSeconds) throw new ArgumentOutOfRangeException(nameof(Seconds),
+                    "The duration is too large for a TimeSpan, which would roll over from positive to negative.");
+
+            if (Seconds < TimeSpan.MinValue.TotalSeconds) throw new ArgumentOutOfRangeException(nameof(Seconds),
+                    "The duration is too small for a TimeSpan, which would roll over from negative to positive.");
+
             return TimeSpan.FromTicks((long)(Seconds * TimeSpan.TicksPerSecond));
         }
 
@@ -33,14 +39,14 @@ public TimeSpan ToTimeSpan()
             return time.AddSeconds(-duration.Seconds);
         }
 
-        /// <summary>Explicitly cast <see cref="Duration"/> to <see cref="TimeSpan"/>.</summary>
-        public static explicit operator TimeSpan(Duration duration)
+        /// <summary>Implicitly cast <see cref="Duration"/> to <see cref="TimeSpan"/>.</summary>
+        public static implicit operator TimeSpan(Duration duration)
         {
             return duration.ToTimeSpan();
         }
 
-        /// <summary>Explicitly cast <see cref="TimeSpan"/> to <see cref="Duration"/>.</summary>
-        public static explicit operator Duration(TimeSpan duration)
+        /// <summary>Implicitly cast <see cref="TimeSpan"/> to <see cref="Duration"/>.</summary>
+        public static implicit operator Duration(TimeSpan duration)
         {
             return FromSeconds(duration.TotalSeconds);
         }