Regenerate code

Author: angularsen

UnitsNet/GeneratedCode/Quantities/BitRate.g.cs

@@ -69,45 +69,70 @@ public sealed partial class MagneticFlux
     public partial struct MagneticFlux : IComparable, IComparable<MagneticFlux>
 #endif
     {
+        private readonly double _value;
+
+        /// <summary>
+        ///     The numeric value this quantity was constructed with.
+        /// </summary>
+#if WINDOWS_UWP
+        public double Value => Convert.ToDouble(_value);
+#else
+        public double Value => _value;
+#endif
+
         /// <summary>
-        ///     Base unit of MagneticFlux.
+        ///     The unit this quantity was constructed with.
         /// </summary>
-        private readonly double _webers;
+        public MagneticFluxUnit Unit { get; }
 
         // Windows Runtime Component requires a default constructor
 #if WINDOWS_UWP
-        public MagneticFlux() : this(0)
+        public MagneticFlux() : this(0, BaseUnit)
         {
         }
 #endif
 
+        [Obsolete("Use the constructor that takes a unit parameter. This constructor will be removed in a future version.")]
         public MagneticFlux(double webers)
         {
-            _webers = Convert.ToDouble(webers);
+            _value = Convert.ToDouble(webers);
+            Unit = BaseUnit;
         }
 
+        /// <summary>
+        ///     Creates the quantity with the given numeric value and unit.
+        /// </summary>
+        /// <param name="numericValue">Numeric value.</param>
+        /// <param name="unit">Unit representation.</param>
+        /// <remarks>Value parameter cannot be named 'value' due to constraint when targeting Windows Runtime Component.</remarks>
+#if WINDOWS_UWP
+        public MagneticFlux(double numericValue, MagneticFluxUnit unit)
+#else
+        public MagneticFlux(double numericValue, MagneticFluxUnit unit)
+#endif
+        {
+            _value = numericValue;
+            Unit = unit;
+         }
+
         // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods
 #if WINDOWS_UWP
         private
 #else
+        [Obsolete("Use the constructor that takes a unit parameter. This constructor will be removed in a future version.")]
         public
 #endif
-        MagneticFlux(long webers)
-        {
-            _webers = Convert.ToDouble(webers);
-        }
+        MagneticFlux(long webers) : this(Convert.ToDouble(webers), BaseUnit) { }
 
         // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods
         // Windows Runtime Component does not support decimal type
 #if WINDOWS_UWP
         private
 #else
+        [Obsolete("Use the constructor that takes a unit parameter. This constructor will be removed in a future version.")]
         public
 #endif
-        MagneticFlux(decimal webers)
-        {
-            _webers = Convert.ToDouble(webers);
-        }
+        MagneticFlux(decimal webers) : this(Convert.ToDouble(webers), BaseUnit) { }
 
         #region Properties
 
@@ -119,50 +144,36 @@ public MagneticFlux(double webers)
         /// <summary>
         ///     The base unit representation of this quantity for the numeric value stored internally. All conversions go via this value.
         /// </summary>
-        public static MagneticFluxUnit BaseUnit
-        {
-            get { return MagneticFluxUnit.Weber; }
-        }
+        public static MagneticFluxUnit BaseUnit => MagneticFluxUnit.Weber;
 
         /// <summary>
         ///     All units of measurement for the MagneticFlux quantity.
         /// </summary>
         public static MagneticFluxUnit[] Units { get; } = Enum.GetValues(typeof(MagneticFluxUnit)).Cast<MagneticFluxUnit>().ToArray();
-
         /// <summary>
         ///     Get MagneticFlux in Webers.
         /// </summary>
-        public double Webers
-        {
-            get { return _webers; }
-        }
+        public double Webers => As(MagneticFluxUnit.Weber);
 
         #endregion
 
         #region Static
 
-        public static MagneticFlux Zero
-        {
-            get { return new MagneticFlux(); }
-        }
+        public static MagneticFlux Zero => new MagneticFlux(0, BaseUnit);
 
         /// <summary>
         ///     Get MagneticFlux from Webers.
         /// </summary>
 #if WINDOWS_UWP
         [Windows.Foundation.Metadata.DefaultOverload]
         public static MagneticFlux FromWebers(double webers)
-        {
-            double value = (double) webers;
-            return new MagneticFlux(value);
-        }
 #else
         public static MagneticFlux FromWebers(QuantityValue webers)
+#endif
         {
             double value = (double) webers;
-            return new MagneticFlux((value));
+            return new MagneticFlux(value, MagneticFluxUnit.Weber);
         }
-#endif
 
         // Windows Runtime Component does not support nullable types (double?): https://msdn.microsoft.com/en-us/library/br230301.aspx
 #if !WINDOWS_UWP
@@ -197,14 +208,7 @@ public static MagneticFlux From(double value, MagneticFluxUnit fromUnit)
         public static MagneticFlux From(QuantityValue value, MagneticFluxUnit fromUnit)
 #endif
         {
-            switch (fromUnit)
-            {
-                case MagneticFluxUnit.Weber:
-                    return FromWebers(value);
-
-                default:
-                    throw new NotImplementedException("fromUnit: " + fromUnit);
-            }
+            return new MagneticFlux((double)value, fromUnit);
         }
 
         // Windows Runtime Component does not support nullable types (double?): https://msdn.microsoft.com/en-us/library/br230301.aspx
@@ -221,14 +225,8 @@ public static MagneticFlux From(QuantityValue value, MagneticFluxUnit fromUnit)
             {
                 return null;
             }
-            switch (fromUnit)
-            {
-                case MagneticFluxUnit.Weber:
-                    return FromWebers(value.Value);
 
-                default:
-                    throw new NotImplementedException("fromUnit: " + fromUnit);
-            }
+            return new MagneticFlux((double)value.Value, fromUnit);
         }
 #endif
 
@@ -263,37 +261,37 @@ public static string GetAbbreviation(MagneticFluxUnit unit, [CanBeNull] Culture
 #if !WINDOWS_UWP
         public static MagneticFlux operator -(MagneticFlux right)
         {
-            return new MagneticFlux(-right._webers);
+            return new MagneticFlux(-right.Value, right.Unit);
         }
 
         public static MagneticFlux operator +(MagneticFlux left, MagneticFlux right)
         {
-            return new MagneticFlux(left._webers + right._webers);
+            return new MagneticFlux(left.Value + right.AsBaseNumericType(left.Unit), left.Unit);
         }
 
         public static MagneticFlux operator -(MagneticFlux left, MagneticFlux right)
         {
-            return new MagneticFlux(left._webers - right._webers);
+            return new MagneticFlux(left.Value - right.AsBaseNumericType(left.Unit), left.Unit);
         }
 
         public static MagneticFlux operator *(double left, MagneticFlux right)
         {
-            return new MagneticFlux(left*right._webers);
+            return new MagneticFlux(left * right.Value, right.Unit);
         }
 
         public static MagneticFlux operator *(MagneticFlux left, double right)
         {
-            return new MagneticFlux(left._webers*(double)right);
+            return new MagneticFlux(left.Value * right, left.Unit);
         }
 
         public static MagneticFlux operator /(MagneticFlux left, double right)
         {
-            return new MagneticFlux(left._webers/(double)right);
+            return new MagneticFlux(left.Value / right, left.Unit);
         }
 
         public static double operator /(MagneticFlux left, MagneticFlux right)
         {
-            return Convert.ToDouble(left._webers/right._webers);
+            return left.Webers / right.Webers;
         }
 #endif
 
@@ -316,43 +314,43 @@ public int CompareTo(object obj)
 #endif
         int CompareTo(MagneticFlux other)
         {
-            return _webers.CompareTo(other._webers);
+            return AsBaseUnitWebers().CompareTo(other.AsBaseUnitWebers());
         }
 
         // Windows Runtime Component does not allow operator overloads: https://msdn.microsoft.com/en-us/library/br230301.aspx
 #if !WINDOWS_UWP
         public static bool operator <=(MagneticFlux left, MagneticFlux right)
         {
-            return left._webers <= right._webers;
+            return left.Value <= right.AsBaseNumericType(left.Unit);
         }
 
         public static bool operator >=(MagneticFlux left, MagneticFlux right)
         {
-            return left._webers >= right._webers;
+            return left.Value >= right.AsBaseNumericType(left.Unit);
         }
 
         public static bool operator <(MagneticFlux left, MagneticFlux right)
         {
-            return left._webers < right._webers;
+            return left.Value < right.AsBaseNumericType(left.Unit);
         }
 
         public static bool operator >(MagneticFlux left, MagneticFlux right)
         {
-            return left._webers > right._webers;
+            return left.Value > right.AsBaseNumericType(left.Unit);
         }
 
         [Obsolete("It is not safe to compare equality due to using System.Double as the internal representation. It is very easy to get slightly different values due to floating point operations. Instead use Equals(other, maxError) to provide the max allowed error.")]
         public static bool operator ==(MagneticFlux left, MagneticFlux right)
         {
             // ReSharper disable once CompareOfFloatsByEqualityOperator
-            return left._webers == right._webers;
+            return left.Value == right.AsBaseNumericType(left.Unit);
         }
 
         [Obsolete("It is not safe to compare equality due to using System.Double as the internal representation. It is very easy to get slightly different values due to floating point operations. Instead use Equals(other, maxError) to provide the max allowed error.")]
         public static bool operator !=(MagneticFlux left, MagneticFlux right)
         {
             // ReSharper disable once CompareOfFloatsByEqualityOperator
-            return left._webers != right._webers;
+            return left.Value != right.AsBaseNumericType(left.Unit);
         }
 #endif
 
@@ -364,7 +362,7 @@ public override bool Equals(object obj)
                 return false;
             }
 
-            return _webers.Equals(((MagneticFlux) obj)._webers);
+            return Value.Equals(((MagneticFlux) obj).AsBaseNumericType(Unit));
         }
 
         /// <summary>
@@ -377,12 +375,12 @@ public override bool Equals(object obj)
         /// <returns>True if the difference between the two values is not greater than the specified max.</returns>
         public bool Equals(MagneticFlux other, MagneticFlux maxError)
         {
-            return Math.Abs(_webers - other._webers) <= maxError._webers;
+            return Math.Abs(Value - other.AsBaseNumericType(Unit)) <= maxError.AsBaseNumericType(Unit);
         }
 
         public override int GetHashCode()
         {
-            return _webers.GetHashCode();
+			return new { Value, Unit }.GetHashCode();
         }
 
         #endregion
@@ -392,14 +390,19 @@ public override int GetHashCode()
         /// <summary>
         ///     Convert to the unit representation <paramref name="unit" />.
         /// </summary>
-        /// <returns>Value in new unit if successful, exception otherwise.</returns>
-        /// <exception cref="NotImplementedException">If conversion was not successful.</exception>
+        /// <returns>Value converted to the specified unit.</returns>
         public double As(MagneticFluxUnit unit)
         {
+            if (Unit == unit)
+            {
+                return (double)Value;
+            }
+
+            double baseUnitValue = AsBaseUnitWebers();
+
             switch (unit)
             {
-                case MagneticFluxUnit.Weber:
-                    return Webers;
+                case MagneticFluxUnit.Weber: return baseUnitValue;
 
                 default:
                     throw new NotImplementedException("unit: " + unit);
@@ -576,6 +579,7 @@ static MagneticFluxUnit ParseUnit(string str, IFormatProvider formatProvider = n
 
         #endregion
 
+        [Obsolete("This should no longer be used. ToString() uses the unit this quantity value was constructed with as default. Pass argument BaseUnit to preserve old behavior.")]
         /// <summary>
         ///     Set the default unit used by ToString(). Default is Weber
         /// </summary>
@@ -587,7 +591,7 @@ static MagneticFluxUnit ParseUnit(string str, IFormatProvider formatProvider = n
         /// <returns>String representation.</returns>
         public override string ToString()
         {
-            return ToString(ToStringDefaultUnit);
+            return ToString(Unit);
         }
 
         /// <summary>
@@ -655,23 +659,31 @@ public string ToString(MagneticFluxUnit unit, [CanBeNull] Culture culture, [NotN
         /// <summary>
         /// Represents the largest possible value of MagneticFlux
         /// </summary>
-        public static MagneticFlux MaxValue
-        {
-            get
-            {
-                return new MagneticFlux(double.MaxValue);
-            }
-        }
+        public static MagneticFlux MaxValue => new MagneticFlux(double.MaxValue, BaseUnit);
 
         /// <summary>
         /// Represents the smallest possible value of MagneticFlux
         /// </summary>
-        public static MagneticFlux MinValue
+        public static MagneticFlux MinValue => new MagneticFlux(double.MinValue, BaseUnit);
+
+        /// <summary>
+        ///     Converts the current value + unit to the base unit.
+        ///     This is typically the first step in converting from one unit to another.
+        /// </summary>
+        /// <returns>The value in the base unit representation.</returns>
+        private double AsBaseUnitWebers()
         {
-            get
+			if (Unit == MagneticFluxUnit.Weber) { return _value; }
+
+            switch (Unit)
             {
-                return new MagneticFlux(double.MinValue);
-            }
-        }
-    }
+                case MagneticFluxUnit.Weber: return _value;
+                default:
+                    throw new NotImplementedException("Unit not implemented: " + Unit);
+			}
+		}
+
+		/// <summary>Convenience method for working with internal numeric type.</summary>
+        private double AsBaseNumericType(MagneticFluxUnit unit) => Convert.ToDouble(As(unit));
+	}
 }