Ran full code cleanup by ReSharper 8 default settings. Mostly XML doc formatting, some re-positioning of class members.

angularsen · angularsen · commit 3b0c218940cc · 2013-08-02T20:38:34.000+02:00
diff --git a/Src/UnitsNet/Mass.cs b/Src/UnitsNet/Mass.cs
@@ -43,7 +43,7 @@ private Mass(double kilograms)
         }
 
         /// <summary>
-        /// The short ton is a unit of mass equal to 2,000 pounds (907.18474 kg), that is most commonly used in the United States – known there simply as the ton. 
+        ///     The short ton is a unit of mass equal to 2,000 pounds (907.18474 kg), that is most commonly used in the United States – known there simply as the ton.
         /// </summary>
         /// <remarks>http://en.wikipedia.org/wiki/Short_ton</remarks>
         public double ShortTons
@@ -52,7 +52,7 @@ public double ShortTons
         }
 
         /// <summary>
-        /// Long ton (weight ton or Imperial ton) is a unit of mass equal to 2,240 pounds (1,016 kg) and is the name for the unit called the "ton" in the avoirdupois or Imperial system of measurements that was used in the United Kingdom and several other Commonwealth countries before metrication.
+        ///     Long ton (weight ton or Imperial ton) is a unit of mass equal to 2,240 pounds (1,016 kg) and is the name for the unit called the "ton" in the avoirdupois or Imperial system of measurements that was used in the United Kingdom and several other Commonwealth countries before metrication.
         /// </summary>
         /// <remarks>http://en.wikipedia.org/wiki/Long_ton</remarks>
         public double LongTons
@@ -185,7 +185,7 @@ public static Mass FromGravitationalForce(Force f)
         }
 
         /// <summary>
-        /// Long ton (weight ton or Imperial ton) is a unit of mass equal to 2,240 pounds (1,016 kg) and is the name for the unit called the "ton" in the avoirdupois or Imperial system of measurements that was used in the United Kingdom and several other Commonwealth countries before metrication.
+        ///     Long ton (weight ton or Imperial ton) is a unit of mass equal to 2,240 pounds (1,016 kg) and is the name for the unit called the "ton" in the avoirdupois or Imperial system of measurements that was used in the United Kingdom and several other Commonwealth countries before metrication.
         /// </summary>
         /// <remarks>http://en.wikipedia.org/wiki/Long_ton</remarks>
         public static Mass FromLongTons(double value)
@@ -194,7 +194,7 @@ public static Mass FromLongTons(double value)
         }
 
         /// <summary>
-        /// The short ton is a unit of mass equal to 2,000 pounds (907.18474 kg), that is most commonly used in the United States – known there simply as the ton. 
+        ///     The short ton is a unit of mass equal to 2,000 pounds (907.18474 kg), that is most commonly used in the United States – known there simply as the ton.
         /// </summary>
         /// <remarks>http://en.wikipedia.org/wiki/Short_ton</remarks>
         public static Mass FromShortTons(double value)
diff --git a/Src/UnitsNet/Pressure.cs b/Src/UnitsNet/Pressure.cs
@@ -259,6 +259,18 @@ public static Pressure FromPsi(double psi)
 
         #region Equality / IComparable
 
+        public int CompareTo(object obj)
+        {
+            if (obj == null) throw new ArgumentNullException("obj");
+            if (!(obj is Pressure)) throw new ArgumentException("Expected type Pressure.", "obj");
+            return CompareTo((Pressure) obj);
+        }
+
+        public int CompareTo(Pressure other)
+        {
+            return Pascals.CompareTo(other.Pascals);
+        }
+
         public override bool Equals(object obj)
         {
             if (ReferenceEquals(null, obj)) return false;
@@ -275,18 +287,6 @@ public override int GetHashCode()
             return Pascals.GetHashCode();
         }
 
-        public int CompareTo(object obj)
-        {
-            if (obj == null) throw new ArgumentNullException("obj");
-            if (!(obj is Pressure)) throw new ArgumentException("Expected type Pressure.", "obj");
-            return CompareTo((Pressure) obj);
-        }
-
-        public int CompareTo(Pressure other)
-        {
-            return Pascals.CompareTo(other.Pascals);
-        }
-
         #endregion
 
         public override string ToString()
diff --git a/Src/UnitsNet/Unit.cs b/Src/UnitsNet/Unit.cs
@@ -56,12 +56,13 @@ public enum Unit
 
         // Mass (imperial)
         /// <summary>
-        /// The short ton is a unit of mass equal to 2,000 pounds (907.18474 kg), that is most commonly used in the United States � known there simply as the ton. 
+        ///     The short ton is a unit of mass equal to 2,000 pounds (907.18474 kg), that is most commonly used in the United States � known there simply as the ton.
         /// </summary>
         /// <remarks>http://en.wikipedia.org/wiki/Short_ton</remarks>
         ShortTon,
+
         /// <summary>
-        /// Long ton (weight ton or Imperial ton) is a unit of mass equal to 2,240 pounds (1,016 kg) and is the name for the unit called the "ton" in the avoirdupois or Imperial system of measurements that was used in the United Kingdom and several other Commonwealth countries before metrication.
+        ///     Long ton (weight ton or Imperial ton) is a unit of mass equal to 2,240 pounds (1,016 kg) and is the name for the unit called the "ton" in the avoirdupois or Imperial system of measurements that was used in the United Kingdom and several other Commonwealth countries before metrication.
         /// </summary>
         /// <remarks>http://en.wikipedia.org/wiki/Long_ton</remarks>
         LongTon,
diff --git a/Src/UnitsNet/UnitValue.cs b/Src/UnitsNet/UnitValue.cs
@@ -39,7 +39,12 @@ public UnitValue(double value, Unit unit)
 
         public bool TryConvert(Unit toUnit, out double newValue)
         {
-            return UnitConverter.TryConvert(this.Value, this.Unit, toUnit, out newValue);
+            return UnitConverter.TryConvert(Value, Unit, toUnit, out newValue);
+        }
+
+        public override string ToString()
+        {
+            return Value + " " + UnitSystem.Create(CultureInfo.CurrentCulture).GetDefaultAbbreviation(Unit);
         }
 
         #region Equality
@@ -92,10 +97,5 @@ public override int GetHashCode()
         }
 
         #endregion
-
-        public override string ToString()
-        {
-            return Value + " " + UnitSystem.Create(CultureInfo.CurrentCulture).GetDefaultAbbreviation(Unit);
-        }
     }
 }
diff --git a/Src/UnitsNet/Volume.cs b/Src/UnitsNet/Volume.cs
@@ -29,12 +29,12 @@ namespace UnitsNet
     public struct Volume : IComparable, IComparable<Volume>
     {
         private const double CubicKilometersToCubicMetersRatio = 1E9;
-        private const double CubicDecimetersToCubicMetersRatio = 1E-3; 
+        private const double CubicDecimetersToCubicMetersRatio = 1E-3;
         private const double CubicCentimetersToCubicMetersRatio = 1E-6;
-        private const double CubicMillimetersToCubicMetersRatio = 1E-9; 
-        private const double HectolitersToCubicMetersRatio = 1E-1; 
-        private const double LitersToCubicMetersRatio = 1E-3; 
-        private const double DecilitersToCubicMetersRatio = 1E-4; 
+        private const double CubicMillimetersToCubicMetersRatio = 1E-9;
+        private const double HectolitersToCubicMetersRatio = 1E-1;
+        private const double LitersToCubicMetersRatio = 1E-3;
+        private const double DecilitersToCubicMetersRatio = 1E-4;
         private const double CentilitersToCubicMetersRatio = 1E-5;
         private const double MillilitersToCubicMetersRatio = 1E-6;
 
@@ -53,47 +53,47 @@ private Volume(double cubicMeters)
 
         public double CubicKilometers
         {
-            get { return CubicMeters / CubicKilometersToCubicMetersRatio; }
+            get { return CubicMeters/CubicKilometersToCubicMetersRatio; }
         }
 
         public double CubicDecimeters
         {
-            get { return CubicMeters / CubicDecimetersToCubicMetersRatio; }
+            get { return CubicMeters/CubicDecimetersToCubicMetersRatio; }
         }
 
         public double CubicCentimeters
         {
-            get { return CubicMeters / CubicCentimetersToCubicMetersRatio; }
+            get { return CubicMeters/CubicCentimetersToCubicMetersRatio; }
         }
 
         public double CubicMillimeters
         {
-            get { return CubicMeters / CubicMillimetersToCubicMetersRatio; }
+            get { return CubicMeters/CubicMillimetersToCubicMetersRatio; }
         }
 
         public double Hectoliters
         {
-            get { return CubicMeters / HectolitersToCubicMetersRatio; }
+            get { return CubicMeters/HectolitersToCubicMetersRatio; }
         }
 
         public double Liters
         {
-            get { return CubicMeters / LitersToCubicMetersRatio; }
+            get { return CubicMeters/LitersToCubicMetersRatio; }
         }
 
         public double Deciliters
         {
-            get { return CubicMeters / DecilitersToCubicMetersRatio; }
+            get { return CubicMeters/DecilitersToCubicMetersRatio; }
         }
 
         public double Centiliters
         {
-            get { return CubicMeters / CentilitersToCubicMetersRatio; }
+            get { return CubicMeters/CentilitersToCubicMetersRatio; }
         }
 
         public double Milliliters
         {
-            get { return CubicMeters / MillilitersToCubicMetersRatio; }
+            get { return CubicMeters/MillilitersToCubicMetersRatio; }
         }
 
         #endregion
@@ -123,7 +123,7 @@ public static Volume Zero
 
         public static Volume FromCubicKilometers(double cubicKilometers)
         {
-            return new Volume(cubicKilometers * CubicKilometersToCubicMetersRatio);
+            return new Volume(cubicKilometers*CubicKilometersToCubicMetersRatio);
         }
 
         public static Volume FromCubicMeters(double cubicMeters)
@@ -133,42 +133,42 @@ public static Volume FromCubicMeters(double cubicMeters)
 
         public static Volume FromCubicDecimeters(double cubicDecimeters)
         {
-            return new Volume(cubicDecimeters * CubicDecimetersToCubicMetersRatio);
+            return new Volume(cubicDecimeters*CubicDecimetersToCubicMetersRatio);
         }
 
         public static Volume FromCubicCentimeters(double cubicCentimeters)
         {
-            return new Volume(cubicCentimeters * CubicCentimetersToCubicMetersRatio);
+            return new Volume(cubicCentimeters*CubicCentimetersToCubicMetersRatio);
         }
 
         public static Volume FromCubicMillimeters(double cubicMillimeters)
         {
-            return new Volume(cubicMillimeters * CubicMillimetersToCubicMetersRatio);
+            return new Volume(cubicMillimeters*CubicMillimetersToCubicMetersRatio);
         }
 
         public static Volume FromHectoliters(double hectoliters)
         {
-            return new Volume(hectoliters * HectolitersToCubicMetersRatio);
+            return new Volume(hectoliters*HectolitersToCubicMetersRatio);
         }
 
         public static Volume FromLiters(double liters)
         {
-            return new Volume(liters * LitersToCubicMetersRatio);
+            return new Volume(liters*LitersToCubicMetersRatio);
         }
 
         public static Volume FromDeciliters(double deciliters)
         {
-            return new Volume(deciliters * DecilitersToCubicMetersRatio);
+            return new Volume(deciliters*DecilitersToCubicMetersRatio);
         }
 
         public static Volume FromCentiliters(double centiliters)
         {
-            return new Volume(centiliters * CentilitersToCubicMetersRatio);
+            return new Volume(centiliters*CentilitersToCubicMetersRatio);
         }
 
         public static Volume FromMilliliters(double milliliters)
         {
-            return new Volume(milliliters * MillilitersToCubicMetersRatio);
+            return new Volume(milliliters*MillilitersToCubicMetersRatio);
         }
 
         #endregion
@@ -232,7 +232,7 @@ public int CompareTo(object obj)
         {
             if (obj == null) throw new ArgumentNullException("obj");
             if (!(obj is Volume)) throw new ArgumentException("Expected type Volume.", "obj");
-            return CompareTo((Volume)obj);
+            return CompareTo((Volume) obj);
         }
 
         public int CompareTo(Volume other)
@@ -247,7 +247,7 @@ public override bool Equals(object obj)
                 return false;
             }
 
-            return CubicMeters.CompareTo(((Volume)obj).CubicMeters) == 0;
+            return CubicMeters.CompareTo(((Volume) obj).CubicMeters) == 0;
         }
 
         public override int GetHashCode()
@@ -262,4 +262,4 @@ public override string ToString()
             return CubicMeters + " m3";
         }
     }
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,12 @@ public UnitValue(double value, Unit unit)`
`39`	`39`
`40`	`40`	`public bool TryConvert(Unit toUnit, out double newValue)`
`41`	`41`	`{`
`42`		`- return UnitConverter.TryConvert(this.Value, this.Unit, toUnit, out newValue);`
	`42`	`+ return UnitConverter.TryConvert(Value, Unit, toUnit, out newValue);`
	`43`	`+ }`
	`44`	`+`
	`45`	`+ public override string ToString()`
	`46`	`+ {`
	`47`	`+ return Value + " " + UnitSystem.Create(CultureInfo.CurrentCulture).GetDefaultAbbreviation(Unit);`
`43`	`48`	`}`
`44`	`49`
`45`	`50`	`#region Equality`
`@@ -92,10 +97,5 @@ public override int GetHashCode()`
`92`	`97`	`}`
`93`	`98`
`94`	`99`	`#endregion`
`95`		`-`
`96`		`- public override string ToString()`
`97`		`- {`
`98`		`- return Value + " " + UnitSystem.Create(CultureInfo.CurrentCulture).GetDefaultAbbreviation(Unit);`
`99`		`- }`
`100`	`100`	`}`
`101`	`101`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,12 +29,12 @@ namespace UnitsNet`
`29`	`29`	`public struct Volume : IComparable, IComparable<Volume>`
`30`	`30`	`{`
`31`	`31`	`private const double CubicKilometersToCubicMetersRatio = 1E9;`
`32`		`- private const double CubicDecimetersToCubicMetersRatio = 1E-3;`
	`32`	`+ private const double CubicDecimetersToCubicMetersRatio = 1E-3;`
`33`	`33`	`private const double CubicCentimetersToCubicMetersRatio = 1E-6;`
`34`		`- private const double CubicMillimetersToCubicMetersRatio = 1E-9;`
`35`		`- private const double HectolitersToCubicMetersRatio = 1E-1;`
`36`		`- private const double LitersToCubicMetersRatio = 1E-3;`
`37`		`- private const double DecilitersToCubicMetersRatio = 1E-4;`
	`34`	`+ private const double CubicMillimetersToCubicMetersRatio = 1E-9;`
	`35`	`+ private const double HectolitersToCubicMetersRatio = 1E-1;`
	`36`	`+ private const double LitersToCubicMetersRatio = 1E-3;`
	`37`	`+ private const double DecilitersToCubicMetersRatio = 1E-4;`
`38`	`38`	`private const double CentilitersToCubicMetersRatio = 1E-5;`
`39`	`39`	`private const double MillilitersToCubicMetersRatio = 1E-6;`
`40`	`40`
`@@ -53,47 +53,47 @@ private Volume(double cubicMeters)`
`53`	`53`
`54`	`54`	`public double CubicKilometers`
`55`	`55`	`{`
`56`		`- get { return CubicMeters / CubicKilometersToCubicMetersRatio; }`
	`56`	`+ get { return CubicMeters/CubicKilometersToCubicMetersRatio; }`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`public double CubicDecimeters`
`60`	`60`	`{`
`61`		`- get { return CubicMeters / CubicDecimetersToCubicMetersRatio; }`
	`61`	`+ get { return CubicMeters/CubicDecimetersToCubicMetersRatio; }`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`public double CubicCentimeters`
`65`	`65`	`{`
`66`		`- get { return CubicMeters / CubicCentimetersToCubicMetersRatio; }`
	`66`	`+ get { return CubicMeters/CubicCentimetersToCubicMetersRatio; }`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`public double CubicMillimeters`
`70`	`70`	`{`
`71`		`- get { return CubicMeters / CubicMillimetersToCubicMetersRatio; }`
	`71`	`+ get { return CubicMeters/CubicMillimetersToCubicMetersRatio; }`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`public double Hectoliters`
`75`	`75`	`{`
`76`		`- get { return CubicMeters / HectolitersToCubicMetersRatio; }`
	`76`	`+ get { return CubicMeters/HectolitersToCubicMetersRatio; }`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`public double Liters`
`80`	`80`	`{`
`81`		`- get { return CubicMeters / LitersToCubicMetersRatio; }`
	`81`	`+ get { return CubicMeters/LitersToCubicMetersRatio; }`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`public double Deciliters`
`85`	`85`	`{`
`86`		`- get { return CubicMeters / DecilitersToCubicMetersRatio; }`
	`86`	`+ get { return CubicMeters/DecilitersToCubicMetersRatio; }`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`public double Centiliters`
`90`	`90`	`{`
`91`		`- get { return CubicMeters / CentilitersToCubicMetersRatio; }`
	`91`	`+ get { return CubicMeters/CentilitersToCubicMetersRatio; }`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`public double Milliliters`
`95`	`95`	`{`
`96`		`- get { return CubicMeters / MillilitersToCubicMetersRatio; }`
	`96`	`+ get { return CubicMeters/MillilitersToCubicMetersRatio; }`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`#endregion`
`@@ -123,7 +123,7 @@ public static Volume Zero`
`123`	`123`
`124`	`124`	`public static Volume FromCubicKilometers(double cubicKilometers)`
`125`	`125`	`{`
`126`		`- return new Volume(cubicKilometers * CubicKilometersToCubicMetersRatio);`
	`126`	`+ return new Volume(cubicKilometers*CubicKilometersToCubicMetersRatio);`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`public static Volume FromCubicMeters(double cubicMeters)`
`@@ -133,42 +133,42 @@ public static Volume FromCubicMeters(double cubicMeters)`
`133`	`133`
`134`	`134`	`public static Volume FromCubicDecimeters(double cubicDecimeters)`
`135`	`135`	`{`
`136`		`- return new Volume(cubicDecimeters * CubicDecimetersToCubicMetersRatio);`
	`136`	`+ return new Volume(cubicDecimeters*CubicDecimetersToCubicMetersRatio);`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`public static Volume FromCubicCentimeters(double cubicCentimeters)`
`140`	`140`	`{`
`141`		`- return new Volume(cubicCentimeters * CubicCentimetersToCubicMetersRatio);`
	`141`	`+ return new Volume(cubicCentimeters*CubicCentimetersToCubicMetersRatio);`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`public static Volume FromCubicMillimeters(double cubicMillimeters)`
`145`	`145`	`{`
`146`		`- return new Volume(cubicMillimeters * CubicMillimetersToCubicMetersRatio);`
	`146`	`+ return new Volume(cubicMillimeters*CubicMillimetersToCubicMetersRatio);`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`public static Volume FromHectoliters(double hectoliters)`
`150`	`150`	`{`
`151`		`- return new Volume(hectoliters * HectolitersToCubicMetersRatio);`
	`151`	`+ return new Volume(hectoliters*HectolitersToCubicMetersRatio);`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`public static Volume FromLiters(double liters)`
`155`	`155`	`{`
`156`		`- return new Volume(liters * LitersToCubicMetersRatio);`
	`156`	`+ return new Volume(liters*LitersToCubicMetersRatio);`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`public static Volume FromDeciliters(double deciliters)`
`160`	`160`	`{`
`161`		`- return new Volume(deciliters * DecilitersToCubicMetersRatio);`
	`161`	`+ return new Volume(deciliters*DecilitersToCubicMetersRatio);`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`public static Volume FromCentiliters(double centiliters)`
`165`	`165`	`{`
`166`		`- return new Volume(centiliters * CentilitersToCubicMetersRatio);`
	`166`	`+ return new Volume(centiliters*CentilitersToCubicMetersRatio);`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`public static Volume FromMilliliters(double milliliters)`
`170`	`170`	`{`
`171`		`- return new Volume(milliliters * MillilitersToCubicMetersRatio);`
	`171`	`+ return new Volume(milliliters*MillilitersToCubicMetersRatio);`
`172`	`172`	`}`
`173`	`173`
`174`	`174`	`#endregion`
`@@ -232,7 +232,7 @@ public int CompareTo(object obj)`
`232`	`232`	`{`
`233`	`233`	`if (obj == null) throw new ArgumentNullException("obj");`
`234`	`234`	`if (!(obj is Volume)) throw new ArgumentException("Expected type Volume.", "obj");`
`235`		`- return CompareTo((Volume)obj);`
	`235`	`+ return CompareTo((Volume) obj);`
`236`	`236`	`}`
`237`	`237`
`238`	`238`	`public int CompareTo(Volume other)`
`@@ -247,7 +247,7 @@ public override bool Equals(object obj)`
`247`	`247`	`return false;`
`248`	`248`	`}`
`249`	`249`
`250`		`- return CubicMeters.CompareTo(((Volume)obj).CubicMeters) == 0;`
	`250`	`+ return CubicMeters.CompareTo(((Volume) obj).CubicMeters) == 0;`
`251`	`251`	`}`
`252`	`252`
`253`	`253`	`public override int GetHashCode()`
`@@ -262,4 +262,4 @@ public override string ToString()`
`262`	`262`	`return CubicMeters + " m3";`
`263`	`263`	`}`
`264`	`264`	`}`
`265`		`-}`
	`265`	`+}`