Adding IQuantity interface. Currently only has the QuantityType and BaseDimensions properties. (#462)

Author: tmilnthorp

Common/GeneratedCode/Quantities/Acceleration.Common.g.cs

@@ -57,9 +57,9 @@ namespace UnitsNet
     // Public structures can't have any members other than public fields, and those fields must be value types or strings.
     // Public classes must be sealed (NotInheritable in Visual Basic). If your programming model requires polymorphism, you can create a public interface and implement that interface on the classes that must be polymorphic.
 #if WINDOWS_UWP
-    public sealed partial class Acceleration
+    public sealed partial class Acceleration : IQuantity
 #else
-    public partial struct Acceleration : IComparable, IComparable<Acceleration>
+    public partial struct Acceleration : IQuantity, IComparable, IComparable<Acceleration>
 #endif
     {
         /// <summary>
@@ -77,6 +77,11 @@ public partial struct Acceleration : IComparable, IComparable<Acceleration>
         /// </summary>
         public AccelerationUnit Unit => _unit.GetValueOrDefault(BaseUnit);
 
+        static Acceleration()
+        {
+            BaseDimensions = new BaseDimensions(1, 0, -2, 0, 0, 0, 0);
+        }
+
         [Obsolete("Use the constructor that takes a unit parameter. This constructor will be removed in a future version.")]
         public Acceleration(double meterspersecondsquared)
         {
@@ -140,14 +145,12 @@ public Acceleration(double meterspersecondsquared)
         /// </summary>
         public static AccelerationUnit BaseUnit => AccelerationUnit.MeterPerSecondSquared;
 
-        private static readonly BaseDimensions _baseDimensions = new BaseDimensions(1, 0, -2, 0, 0, 0, 0);
-
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
         public static BaseDimensions BaseDimensions
         {
-            get{ return _baseDimensions; }
+            get;
         }
 
         /// <summary>
@@ -983,6 +986,11 @@ public string ToString(
         /// </summary>
         public static Acceleration MinValue => new Acceleration(double.MinValue, BaseUnit);
 
+        /// <summary>
+        ///     The <see cref="QuantityType" /> of this quantity.
+        /// </summary>
+        public QuantityType Type => Acceleration.QuantityType;
+
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>

Common/GeneratedCode/Quantities/AmountOfSubstance.Common.g.cs

@@ -57,9 +57,9 @@ namespace UnitsNet
     // Public structures can't have any members other than public fields, and those fields must be value types or strings.
     // Public classes must be sealed (NotInheritable in Visual Basic). If your programming model requires polymorphism, you can create a public interface and implement that interface on the classes that must be polymorphic.
 #if WINDOWS_UWP
-    public sealed partial class AmountOfSubstance
+    public sealed partial class AmountOfSubstance : IQuantity
 #else
-    public partial struct AmountOfSubstance : IComparable, IComparable<AmountOfSubstance>
+    public partial struct AmountOfSubstance : IQuantity, IComparable, IComparable<AmountOfSubstance>
 #endif
     {
         /// <summary>
@@ -77,6 +77,11 @@ public partial struct AmountOfSubstance : IComparable, IComparable<AmountOfSubst
         /// </summary>
         public AmountOfSubstanceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
 
+        static AmountOfSubstance()
+        {
+            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 0, 1, 0);
+        }
+
         [Obsolete("Use the constructor that takes a unit parameter. This constructor will be removed in a future version.")]
         public AmountOfSubstance(double moles)
         {
@@ -140,14 +145,12 @@ public AmountOfSubstance(double moles)
         /// </summary>
         public static AmountOfSubstanceUnit BaseUnit => AmountOfSubstanceUnit.Mole;
 
-        private static readonly BaseDimensions _baseDimensions = new BaseDimensions(0, 0, 0, 0, 0, 1, 0);
-
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
         public static BaseDimensions BaseDimensions
         {
-            get{ return _baseDimensions; }
+            get;
         }
 
         /// <summary>
@@ -1003,6 +1006,11 @@ public string ToString(
         /// </summary>
         public static AmountOfSubstance MinValue => new AmountOfSubstance(double.MinValue, BaseUnit);
 
+        /// <summary>
+        ///     The <see cref="QuantityType" /> of this quantity.
+        /// </summary>
+        public QuantityType Type => AmountOfSubstance.QuantityType;
+
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>

Common/GeneratedCode/Quantities/AmplitudeRatio.Common.g.cs

@@ -57,9 +57,9 @@ namespace UnitsNet
     // Public structures can't have any members other than public fields, and those fields must be value types or strings.
     // Public classes must be sealed (NotInheritable in Visual Basic). If your programming model requires polymorphism, you can create a public interface and implement that interface on the classes that must be polymorphic.
 #if WINDOWS_UWP
-    public sealed partial class AmplitudeRatio
+    public sealed partial class AmplitudeRatio : IQuantity
 #else
-    public partial struct AmplitudeRatio : IComparable, IComparable<AmplitudeRatio>
+    public partial struct AmplitudeRatio : IQuantity, IComparable, IComparable<AmplitudeRatio>
 #endif
     {
         /// <summary>
@@ -77,6 +77,10 @@ public partial struct AmplitudeRatio : IComparable, IComparable<AmplitudeRatio>
         /// </summary>
         public AmplitudeRatioUnit Unit => _unit.GetValueOrDefault(BaseUnit);
 
+        static AmplitudeRatio()
+        {
+        }
+
         [Obsolete("Use the constructor that takes a unit parameter. This constructor will be removed in a future version.")]
         public AmplitudeRatio(double decibelvolts)
         {
@@ -140,6 +144,14 @@ public AmplitudeRatio(double decibelvolts)
         /// </summary>
         public static AmplitudeRatioUnit BaseUnit => AmplitudeRatioUnit.DecibelVolt;
 
+        /// <summary>
+        ///     The <see cref="BaseDimensions" /> of this quantity.
+        /// </summary>
+        public static BaseDimensions BaseDimensions
+        {
+            get;
+        }
+
         /// <summary>
         ///     All units of measurement for the AmplitudeRatio quantity.
         /// </summary>
@@ -793,5 +805,14 @@ public string ToString(
         /// </summary>
         public static AmplitudeRatio MinValue => new AmplitudeRatio(double.MinValue, BaseUnit);
 
+        /// <summary>
+        ///     The <see cref="QuantityType" /> of this quantity.
+        /// </summary>
+        public QuantityType Type => AmplitudeRatio.QuantityType;
+
+        /// <summary>
+        ///     The <see cref="BaseDimensions" /> of this quantity.
+        /// </summary>
+        public BaseDimensions Dimensions => AmplitudeRatio.BaseDimensions;
     }
 }

Common/GeneratedCode/Quantities/Angle.Common.g.cs

@@ -57,9 +57,9 @@ namespace UnitsNet
     // Public structures can't have any members other than public fields, and those fields must be value types or strings.
     // Public classes must be sealed (NotInheritable in Visual Basic). If your programming model requires polymorphism, you can create a public interface and implement that interface on the classes that must be polymorphic.
 #if WINDOWS_UWP
-    public sealed partial class Angle
+    public sealed partial class Angle : IQuantity
 #else
-    public partial struct Angle : IComparable, IComparable<Angle>
+    public partial struct Angle : IQuantity, IComparable, IComparable<Angle>
 #endif
     {
         /// <summary>
@@ -77,6 +77,10 @@ public partial struct Angle : IComparable, IComparable<Angle>
         /// </summary>
         public AngleUnit Unit => _unit.GetValueOrDefault(BaseUnit);
 
+        static Angle()
+        {
+        }
+
         [Obsolete("Use the constructor that takes a unit parameter. This constructor will be removed in a future version.")]
         public Angle(double degrees)
         {
@@ -140,6 +144,14 @@ public Angle(double degrees)
         /// </summary>
         public static AngleUnit BaseUnit => AngleUnit.Degree;
 
+        /// <summary>
+        ///     The <see cref="BaseDimensions" /> of this quantity.
+        /// </summary>
+        public static BaseDimensions BaseDimensions
+        {
+            get;
+        }
+
         /// <summary>
         ///     All units of measurement for the Angle quantity.
         /// </summary>
@@ -993,5 +1005,14 @@ public string ToString(
         /// </summary>
         public static Angle MinValue => new Angle(double.MinValue, BaseUnit);
 
+        /// <summary>
+        ///     The <see cref="QuantityType" /> of this quantity.
+        /// </summary>
+        public QuantityType Type => Angle.QuantityType;
+
+        /// <summary>
+        ///     The <see cref="BaseDimensions" /> of this quantity.
+        /// </summary>
+        public BaseDimensions Dimensions => Angle.BaseDimensions;
     }
 }

Common/GeneratedCode/Quantities/ApparentEnergy.Common.g.cs

@@ -57,9 +57,9 @@ namespace UnitsNet
     // Public structures can't have any members other than public fields, and those fields must be value types or strings.
     // Public classes must be sealed (NotInheritable in Visual Basic). If your programming model requires polymorphism, you can create a public interface and implement that interface on the classes that must be polymorphic.
 #if WINDOWS_UWP
-    public sealed partial class ApparentEnergy
+    public sealed partial class ApparentEnergy : IQuantity
 #else
-    public partial struct ApparentEnergy : IComparable, IComparable<ApparentEnergy>
+    public partial struct ApparentEnergy : IQuantity, IComparable, IComparable<ApparentEnergy>
 #endif
     {
         /// <summary>
@@ -77,6 +77,11 @@ public partial struct ApparentEnergy : IComparable, IComparable<ApparentEnergy>
         /// </summary>
         public ApparentEnergyUnit Unit => _unit.GetValueOrDefault(BaseUnit);
 
+        static ApparentEnergy()
+        {
+            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0);
+        }
+
         [Obsolete("Use the constructor that takes a unit parameter. This constructor will be removed in a future version.")]
         public ApparentEnergy(double voltamperehours)
         {
@@ -140,14 +145,12 @@ public ApparentEnergy(double voltamperehours)
         /// </summary>
         public static ApparentEnergyUnit BaseUnit => ApparentEnergyUnit.VoltampereHour;
 
-        private static readonly BaseDimensions _baseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0);
-
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
         public static BaseDimensions BaseDimensions
         {
-            get{ return _baseDimensions; }
+            get;
         }
 
         /// <summary>
@@ -783,6 +786,11 @@ public string ToString(
         /// </summary>
         public static ApparentEnergy MinValue => new ApparentEnergy(double.MinValue, BaseUnit);
 
+        /// <summary>
+        ///     The <see cref="QuantityType" /> of this quantity.
+        /// </summary>
+        public QuantityType Type => ApparentEnergy.QuantityType;
+
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>

Common/GeneratedCode/Quantities/ApparentPower.Common.g.cs

@@ -57,9 +57,9 @@ namespace UnitsNet
     // Public structures can't have any members other than public fields, and those fields must be value types or strings.
     // Public classes must be sealed (NotInheritable in Visual Basic). If your programming model requires polymorphism, you can create a public interface and implement that interface on the classes that must be polymorphic.
 #if WINDOWS_UWP
-    public sealed partial class ApparentPower
+    public sealed partial class ApparentPower : IQuantity
 #else
-    public partial struct ApparentPower : IComparable, IComparable<ApparentPower>
+    public partial struct ApparentPower : IQuantity, IComparable, IComparable<ApparentPower>
 #endif
     {
         /// <summary>
@@ -77,6 +77,11 @@ public partial struct ApparentPower : IComparable, IComparable<ApparentPower>
         /// </summary>
         public ApparentPowerUnit Unit => _unit.GetValueOrDefault(BaseUnit);
 
+        static ApparentPower()
+        {
+            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0);
+        }
+
         [Obsolete("Use the constructor that takes a unit parameter. This constructor will be removed in a future version.")]
         public ApparentPower(double voltamperes)
         {
@@ -140,14 +145,12 @@ public ApparentPower(double voltamperes)
         /// </summary>
         public static ApparentPowerUnit BaseUnit => ApparentPowerUnit.Voltampere;
 
-        private static readonly BaseDimensions _baseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0);
-
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
         public static BaseDimensions BaseDimensions
         {
-            get{ return _baseDimensions; }
+            get;
         }
 
         /// <summary>
@@ -803,6 +806,11 @@ public string ToString(
         /// </summary>
         public static ApparentPower MinValue => new ApparentPower(double.MinValue, BaseUnit);
 
+        /// <summary>
+        ///     The <see cref="QuantityType" /> of this quantity.
+        /// </summary>
+        public QuantityType Type => ApparentPower.QuantityType;
+
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>

Common/GeneratedCode/Quantities/Area.Common.g.cs

@@ -57,9 +57,9 @@ namespace UnitsNet
     // Public structures can't have any members other than public fields, and those fields must be value types or strings.
     // Public classes must be sealed (NotInheritable in Visual Basic). If your programming model requires polymorphism, you can create a public interface and implement that interface on the classes that must be polymorphic.
 #if WINDOWS_UWP
-    public sealed partial class Area
+    public sealed partial class Area : IQuantity
 #else
-    public partial struct Area : IComparable, IComparable<Area>
+    public partial struct Area : IQuantity, IComparable, IComparable<Area>
 #endif
     {
         /// <summary>
@@ -77,6 +77,11 @@ public partial struct Area : IComparable, IComparable<Area>
         /// </summary>
         public AreaUnit Unit => _unit.GetValueOrDefault(BaseUnit);
 
+        static Area()
+        {
+            BaseDimensions = new BaseDimensions(2, 0, 0, 0, 0, 0, 0);
+        }
+
         [Obsolete("Use the constructor that takes a unit parameter. This constructor will be removed in a future version.")]
         public Area(double squaremeters)
         {
@@ -140,14 +145,12 @@ public Area(double squaremeters)
         /// </summary>
         public static AreaUnit BaseUnit => AreaUnit.SquareMeter;
 
-        private static readonly BaseDimensions _baseDimensions = new BaseDimensions(2, 0, 0, 0, 0, 0, 0);
-
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>
         public static BaseDimensions BaseDimensions
         {
-            get{ return _baseDimensions; }
+            get;
         }
 
         /// <summary>
@@ -983,6 +986,11 @@ public string ToString(
         /// </summary>
         public static Area MinValue => new Area(double.MinValue, BaseUnit);
 
+        /// <summary>
+        ///     The <see cref="QuantityType" /> of this quantity.
+        /// </summary>
+        public QuantityType Type => Area.QuantityType;
+
         /// <summary>
         ///     The <see cref="BaseDimensions" /> of this quantity.
         /// </summary>