diff --git a/Source/Meadow.Units/Angle.cs b/Source/Meadow.Units/Angle.cs
index e5fc443..b2680d2 100644
--- a/Source/Meadow.Units/Angle.cs
+++ b/Source/Meadow.Units/Angle.cs
@@ -17,6 +17,18 @@ public struct Angle :
     IComparable, IFormattable, IConvertible,
     IEquatable<double>, IComparable<double>
 {
+    private static Angle _zero;
+
+    static Angle()
+    {
+        _zero = new Angle(0, UnitType.Degrees);
+    }
+
+    /// <summary>
+    /// Gets an angle with a value of zero
+    /// </summary>
+    public static Angle Zero => _zero;
+
     /// <summary>
     /// Creates a new `Angle` object.
     /// </summary>
@@ -24,7 +36,7 @@ public struct Angle :
     /// <param name="type">Degrees by default.</param>
     public Angle(double value, UnitType type = UnitType.Degrees)
     {
-        Value = AngleConversions.Convert(value, type, UnitType.Degrees);
+        _value = AngleConversions.Convert(value, type, UnitType.Degrees);
     }
 
     /// <summary>
@@ -33,13 +45,13 @@ public Angle(double value, UnitType type = UnitType.Degrees)
     /// <param name="angle"></param>
     public Angle(Angle angle)
     {
-        Value = angle.Value;
+        _value = angle._value;
     }
 
     /// <summary>
     /// Internal canonical value.
     /// </summary>
-    private readonly double Value;
+    private readonly double _value;
 
     /// <summary>
     /// The type of units available to describe the Angle.
@@ -110,7 +122,7 @@ public enum UnitType
     [Pure]
     public double From(UnitType convertTo)
     {
-        return AngleConversions.Convert(Value, UnitType.Degrees, convertTo);
+        return AngleConversions.Convert(_value, UnitType.Degrees, convertTo);
     }
 
     /// <summary>
@@ -130,7 +142,7 @@ public override bool Equals(object obj)
     /// Get hash of object
     /// </summary>
     /// <returns>int32 hash value</returns>
-    [Pure] public override int GetHashCode() => Value.GetHashCode();
+    [Pure] public override int GetHashCode() => _value.GetHashCode();
 
     // implicit conversions
     //[Pure] public static implicit operator Angle(ushort value) => new Angle(value);
@@ -148,7 +160,7 @@ public override bool Equals(object obj)
     /// </summary>
     /// <param name="other">The object to compare</param>
     /// <returns>true if equal</returns>
-    [Pure] public bool Equals(Angle other) => Value == other.Value;
+    [Pure] public bool Equals(Angle other) => _value == other._value;
 
     /// <summary>
     /// Equals operator to compare two Angle objects
@@ -156,7 +168,7 @@ public override bool Equals(object obj)
     /// <param name="left">left value</param>
     /// <param name="right">right value</param>
     /// <returns>true if equal</returns>
-    [Pure] public static bool operator ==(Angle left, Angle right) => Equals(left.Value, right.Value);
+    [Pure] public static bool operator ==(Angle left, Angle right) => Equals(left._value, right._value);
 
     /// <summary>
     /// Not equals operator to compare two Angle objects
@@ -164,14 +176,14 @@ public override bool Equals(object obj)
     /// <param name="left">left value</param>
     /// <param name="right">right value</param>
     /// <returns>true if not equal</returns>
-    [Pure] public static bool operator !=(Angle left, Angle right) => !Equals(left.Value, right.Value);
+    [Pure] public static bool operator !=(Angle left, Angle right) => !Equals(left._value, right._value);
 
     /// <summary>
     /// Compare to another Angle object
     /// </summary>
     /// <param name="other"></param>
     /// <returns>0 if equal</returns>
-    [Pure] public int CompareTo(Angle other) => Equals(Value, other.Value) ? 0 : Value.CompareTo(other.Value);
+    [Pure] public int CompareTo(Angle other) => Equals(_value, other._value) ? 0 : _value.CompareTo(other._value);
 
     /// <summary>
     /// Less than operator to compare two Angle objects
@@ -179,7 +191,7 @@ public override bool Equals(object obj)
     /// <param name="left">left value</param>
     /// <param name="right">right value</param>
     /// <returns>true if left is less than right</returns>
-    [Pure] public static bool operator <(Angle left, Angle right) => Comparer<double>.Default.Compare(left.Value, right.Value) < 0;
+    [Pure] public static bool operator <(Angle left, Angle right) => Comparer<double>.Default.Compare(left._value, right._value) < 0;
 
     /// <summary>
     /// Greater than operator to compare two Angle objects
@@ -187,7 +199,7 @@ public override bool Equals(object obj)
     /// <param name="left">left value</param>
     /// <param name="right">right value</param>
     /// <returns>true if left is greater than right</returns>
-    [Pure] public static bool operator >(Angle left, Angle right) => Comparer<double>.Default.Compare(left.Value, right.Value) > 0;
+    [Pure] public static bool operator >(Angle left, Angle right) => Comparer<double>.Default.Compare(left._value, right._value) > 0;
 
     /// <summary>
     /// Less than or equal operator to compare two Angle objects
@@ -195,7 +207,7 @@ public override bool Equals(object obj)
     /// <param name="left">left value</param>
     /// <param name="right">right value</param>
     /// <returns>true if left is less than or equal to right</returns>
-    [Pure] public static bool operator <=(Angle left, Angle right) => Comparer<double>.Default.Compare(left.Value, right.Value) <= 0;
+    [Pure] public static bool operator <=(Angle left, Angle right) => Comparer<double>.Default.Compare(left._value, right._value) <= 0;
 
     /// <summary>
     /// Greater than or equal operator to compare two Angle objects
@@ -203,7 +215,7 @@ public override bool Equals(object obj)
     /// <param name="left">left value</param>
     /// <param name="right">right value</param>
     /// <returns>true if left is greater than or equal to right</returns>
-    [Pure] public static bool operator >=(Angle left, Angle right) => Comparer<double>.Default.Compare(left.Value, right.Value) >= 0;
+    [Pure] public static bool operator >=(Angle left, Angle right) => Comparer<double>.Default.Compare(left._value, right._value) >= 0;
 
     // Math
     /// <summary>
@@ -212,7 +224,7 @@ public override bool Equals(object obj)
     /// <param name="left">left value</param>
     /// <param name="right">right value</param>
     /// <returns>A new Angle object with a value of left + right</returns>
-    [Pure] public static Angle operator +(Angle left, Angle right) => new(left.Value + right.Value);
+    [Pure] public static Angle operator +(Angle left, Angle right) => new(left._value + right._value);
 
     /// <summary>
     /// Subtraction operator to subtract two Angle objects
@@ -220,7 +232,7 @@ public override bool Equals(object obj)
     /// <param name="left">left value</param>
     /// <param name="right">right value</param>
     /// <returns>A new Angle object with a value of left - right</returns>
-    [Pure] public static Angle operator -(Angle left, Angle right) => new(left.Value - right.Value);
+    [Pure] public static Angle operator -(Angle left, Angle right) => new(left._value - right._value);
 
     /// <summary>
     /// Multiplication operator to multiply by a double
@@ -228,7 +240,7 @@ public override bool Equals(object obj)
     /// <param name="value">object to multiply</param>
     /// <param name="operand">operand to multiply object</param>
     /// <returns>A new Angle object with a value of value multiplied by the operand</returns>
-    [Pure] public static Angle operator *(Angle value, double operand) => new(value.Value * operand);
+    [Pure] public static Angle operator *(Angle value, double operand) => new(value._value * operand);
 
     /// <summary>
     /// Division operator to divide by a double
@@ -236,19 +248,19 @@ public override bool Equals(object obj)
     /// <param name="value">object to be divided</param>
     /// <param name="operand">operand to divide object</param>
     /// <returns>A new Angle object with a value of value divided by the operand</returns>
-    [Pure] public static Angle operator /(Angle value, double operand) => new(value.Value / operand);
+    [Pure] public static Angle operator /(Angle value, double operand) => new(value._value / operand);
 
     /// <summary>
     /// Returns the absolute value of the <see cref="Angle"/>
     /// </summary>
     /// <returns></returns>
-    [Pure] public Angle Abs() { return new Angle(Math.Abs(this.Value)); }
+    [Pure] public Angle Abs() { return new Angle(Math.Abs(this._value)); }
 
     /// <summary>
     /// Get a string representation of the object
     /// </summary>
     /// <returns>A string representing the object</returns>
-    [Pure] public override string ToString() => Value.ToString();
+    [Pure] public override string ToString() => _value.ToString();
 
     /// <summary>
     /// Get a string representation of the object
@@ -256,7 +268,7 @@ public override bool Equals(object obj)
     /// <param name="format">format</param>
     /// <param name="formatProvider">format provider</param>
     /// <returns>A string representing the object</returns>
-    [Pure] public string ToString(string format, IFormatProvider formatProvider) => Value.ToString(format, formatProvider);
+    [Pure] public string ToString(string format, IFormatProvider formatProvider) => _value.ToString(format, formatProvider);
 
     // IComparable
     /// <summary>
@@ -264,97 +276,97 @@ public override bool Equals(object obj)
     /// </summary>
     /// <param name="obj">The other Angle cast to object</param>
     /// <returns>0 if equal</returns>
-    [Pure] public int CompareTo(object obj) => Value.CompareTo(obj);
+    [Pure] public int CompareTo(object obj) => _value.CompareTo(obj);
 
     /// <summary>
     /// Get type code of object
     /// </summary>
     /// <returns>The TypeCode</returns>
-    [Pure] public TypeCode GetTypeCode() => Value.GetTypeCode();
+    [Pure] public TypeCode GetTypeCode() => _value.GetTypeCode();
 
     /// <summary>
     /// Convert to boolean
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>bool representation of the object</returns>
-    [Pure] public bool ToBoolean(IFormatProvider provider) => ((IConvertible)Value).ToBoolean(provider);
+    [Pure] public bool ToBoolean(IFormatProvider provider) => ((IConvertible)_value).ToBoolean(provider);
 
     /// <summary>
     /// Convert to byte
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>byte representation of the object</returns>
-    [Pure] public byte ToByte(IFormatProvider provider) => ((IConvertible)Value).ToByte(provider);
+    [Pure] public byte ToByte(IFormatProvider provider) => ((IConvertible)_value).ToByte(provider);
 
     /// <summary>
     /// Convert to char
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>char representation of the object</returns>
-    [Pure] public char ToChar(IFormatProvider provider) => ((IConvertible)Value).ToChar(provider);
+    [Pure] public char ToChar(IFormatProvider provider) => ((IConvertible)_value).ToChar(provider);
 
     /// <summary>
     /// Convert to DateTime
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>DateTime representation of the object</returns>
-    [Pure] public DateTime ToDateTime(IFormatProvider provider) => ((IConvertible)Value).ToDateTime(provider);
+    [Pure] public DateTime ToDateTime(IFormatProvider provider) => ((IConvertible)_value).ToDateTime(provider);
 
     /// <summary>
     /// Convert to Decimal
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>Decimal representation of the object</returns>
-    [Pure] public decimal ToDecimal(IFormatProvider provider) => ((IConvertible)Value).ToDecimal(provider);
+    [Pure] public decimal ToDecimal(IFormatProvider provider) => ((IConvertible)_value).ToDecimal(provider);
 
     /// <summary>
     /// Convert to double
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>double representation of the object</returns>
-    [Pure] public double ToDouble(IFormatProvider provider) => Value;
+    [Pure] public double ToDouble(IFormatProvider provider) => _value;
 
     /// <summary>
     /// Convert to in16
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>int16 representation of the object</returns>
-    [Pure] public short ToInt16(IFormatProvider provider) => ((IConvertible)Value).ToInt16(provider);
+    [Pure] public short ToInt16(IFormatProvider provider) => ((IConvertible)_value).ToInt16(provider);
 
     /// <summary>
     /// Convert to int32
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>int32 representation of the object</returns>
-    [Pure] public int ToInt32(IFormatProvider provider) => ((IConvertible)Value).ToInt32(provider);
+    [Pure] public int ToInt32(IFormatProvider provider) => ((IConvertible)_value).ToInt32(provider);
 
     /// <summary>
     /// Convert to int64
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>int64 representation of the object</returns>
-    [Pure] public long ToInt64(IFormatProvider provider) => ((IConvertible)Value).ToInt64(provider);
+    [Pure] public long ToInt64(IFormatProvider provider) => ((IConvertible)_value).ToInt64(provider);
 
     /// <summary>
     /// Convert to sbyte
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>sbyte representation of the object</returns>
-    [Pure] public sbyte ToSByte(IFormatProvider provider) => ((IConvertible)Value).ToSByte(provider);
+    [Pure] public sbyte ToSByte(IFormatProvider provider) => ((IConvertible)_value).ToSByte(provider);
 
     /// <summary>
     /// Convert to float
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>float representation of the object</returns>
-    [Pure] public float ToSingle(IFormatProvider provider) => ((IConvertible)Value).ToSingle(provider);
+    [Pure] public float ToSingle(IFormatProvider provider) => ((IConvertible)_value).ToSingle(provider);
 
     /// <summary>
     /// Convert to string
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>string representation of the object</returns>
-    [Pure] public string ToString(IFormatProvider provider) => Value.ToString(provider);
+    [Pure] public string ToString(IFormatProvider provider) => _value.ToString(provider);
 
     /// <summary>
     /// Convert to type
@@ -362,28 +374,28 @@ public override bool Equals(object obj)
     /// <param name="conversionType">conversion type</param>
     /// <param name="provider">format provider</param>
     /// <returns>type representation of the object</returns>
-    [Pure] public object ToType(Type conversionType, IFormatProvider provider) => ((IConvertible)Value).ToType(conversionType, provider);
+    [Pure] public object ToType(Type conversionType, IFormatProvider provider) => ((IConvertible)_value).ToType(conversionType, provider);
 
     /// <summary>
     /// Convert to uint16
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>uint16 representation of the object</returns>
-    [Pure] public ushort ToUInt16(IFormatProvider provider) => ((IConvertible)Value).ToUInt16(provider);
+    [Pure] public ushort ToUInt16(IFormatProvider provider) => ((IConvertible)_value).ToUInt16(provider);
 
     /// <summary>
     /// Convert to uint32
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>uint32 representation of the object</returns>
-    [Pure] public uint ToUInt32(IFormatProvider provider) => ((IConvertible)Value).ToUInt32(provider);
+    [Pure] public uint ToUInt32(IFormatProvider provider) => ((IConvertible)_value).ToUInt32(provider);
 
     /// <summary>
     /// Convert to uint64
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>uint64 representation of the object</returns>
-    [Pure] public ulong ToUInt64(IFormatProvider provider) => ((IConvertible)Value).ToUInt64(provider);
+    [Pure] public ulong ToUInt64(IFormatProvider provider) => ((IConvertible)_value).ToUInt64(provider);
 
     /// <summary>
     /// Compare the default value to a double 
@@ -393,7 +405,7 @@ public override bool Equals(object obj)
     [Pure]
     public int CompareTo(double? other)
     {
-        return (other is null) ? -1 : (Value).CompareTo(other.Value);
+        return (other is null) ? -1 : (_value).CompareTo(other.Value);
     }
 
     /// <summary>
@@ -401,19 +413,19 @@ public int CompareTo(double? other)
     /// </summary>
     /// <param name="other">value to compare</param>
     /// <returns>0 if equal</returns>
-    [Pure] public bool Equals(double? other) => Value.Equals(other);
+    [Pure] public bool Equals(double? other) => _value.Equals(other);
 
     /// <summary>
     /// Compare the default value to a double 
     /// </summary>
     /// <param name="other">value to compare</param>
     /// <returns>0 if equal</returns>
-    [Pure] public bool Equals(double other) => Value.Equals(other);
+    [Pure] public bool Equals(double other) => _value.Equals(other);
 
     /// <summary>
     /// Compare the default value to a double 
     /// </summary>
     /// <param name="other">value to compare</param>
     /// <returns>0 if equal</returns>
-    [Pure] public int CompareTo(double other) => Value.CompareTo(other);
+    [Pure] public int CompareTo(double other) => _value.CompareTo(other);
 }
\ No newline at end of file
diff --git a/Source/Meadow.Units/Length.cs b/Source/Meadow.Units/Length.cs
index 1d0cdac..980c97e 100644
--- a/Source/Meadow.Units/Length.cs
+++ b/Source/Meadow.Units/Length.cs
@@ -17,6 +17,18 @@ public struct Length :
     IComparable, IFormattable, IConvertible,
     IEquatable<double>, IComparable<double>
 {
+    private static Length _zero;
+
+    static Length()
+    {
+        _zero = new Length(0, UnitType.Meters);
+    }
+
+    /// <summary>
+    /// Gets a length with a value of zero
+    /// </summary>
+    public static Length Zero => _zero;
+
     /// <summary>
     /// Creates a new `Length` object.
     /// </summary>
@@ -24,7 +36,7 @@ public struct Length :
     /// <param name="type">Meters by default.</param>
     public Length(double value, UnitType type = UnitType.Meters)
     {
-        Value = LengthConversions.Convert(value, type, UnitType.Meters);
+        _value = LengthConversions.Convert(value, type, UnitType.Meters);
     }
 
     /// <summary>
@@ -33,13 +45,13 @@ public Length(double value, UnitType type = UnitType.Meters)
     /// <param name="length"></param>
     public Length(Length length)
     {
-        this.Value = length.Value;
+        this._value = length._value;
     }
 
     /// <summary>
     /// Internal canonical value.
     /// </summary>
-    private readonly double Value;
+    private readonly double _value;
 
     /// <summary>
     /// The type of units available to describe the Length.
@@ -153,7 +165,7 @@ public enum UnitType
     [Pure]
     public readonly double From(UnitType convertTo)
     {
-        return LengthConversions.Convert(Value, UnitType.Meters, convertTo);
+        return LengthConversions.Convert(_value, UnitType.Meters, convertTo);
     }
 
     /// <summary>
@@ -173,7 +185,7 @@ public override readonly bool Equals(object obj)
     /// Get hash of object
     /// </summary>
     /// <returns>int32 hash value</returns>
-    [Pure] public override readonly int GetHashCode() => Value.GetHashCode();
+    [Pure] public override readonly int GetHashCode() => _value.GetHashCode();
 
     // implicit conversions
     //[Pure] public static implicit operator Length(ushort value) => new Length(value);
@@ -191,7 +203,7 @@ public override readonly bool Equals(object obj)
     /// </summary>
     /// <param name="other">The object to compare</param>
     /// <returns>true if equal</returns>
-    [Pure] public readonly bool Equals(Length other) => Value == other.Value;
+    [Pure] public readonly bool Equals(Length other) => _value == other._value;
 
     /// <summary>
     /// Equals operator to compare two Length objects
@@ -199,7 +211,7 @@ public override readonly bool Equals(object obj)
     /// <param name="left">left value</param>
     /// <param name="right">right value</param>
     /// <returns>true if equal</returns>
-    [Pure] public static bool operator ==(Length left, Length right) => Equals(left.Value, right.Value);
+    [Pure] public static bool operator ==(Length left, Length right) => Equals(left._value, right._value);
 
     /// <summary>
     /// Not equals operator to compare two Length objects
@@ -207,14 +219,14 @@ public override readonly bool Equals(object obj)
     /// <param name="left">left value</param>
     /// <param name="right">right value</param>
     /// <returns>true if not equal</returns>
-    [Pure] public static bool operator !=(Length left, Length right) => !Equals(left.Value, right.Value);
+    [Pure] public static bool operator !=(Length left, Length right) => !Equals(left._value, right._value);
 
     /// <summary>
     /// Compare to another Length object
     /// </summary>
     /// <param name="other"></param>
     /// <returns>0 if equal</returns>
-    [Pure] public readonly int CompareTo(Length other) => Equals(Value, other.Value) ? 0 : Value.CompareTo(other.Value);
+    [Pure] public readonly int CompareTo(Length other) => Equals(_value, other._value) ? 0 : _value.CompareTo(other._value);
 
     /// <summary>
     /// Less than operator to compare two Length objects
@@ -222,7 +234,7 @@ public override readonly bool Equals(object obj)
     /// <param name="left">left value</param>
     /// <param name="right">right value</param>
     /// <returns>true if left is less than right</returns>
-    [Pure] public static bool operator <(Length left, Length right) => Comparer<double>.Default.Compare(left.Value, right.Value) < 0;
+    [Pure] public static bool operator <(Length left, Length right) => Comparer<double>.Default.Compare(left._value, right._value) < 0;
 
     /// <summary>
     /// Greater than operator to compare two Length objects
@@ -230,7 +242,7 @@ public override readonly bool Equals(object obj)
     /// <param name="left">left value</param>
     /// <param name="right">right value</param>
     /// <returns>true if left is greater than right</returns>
-    [Pure] public static bool operator >(Length left, Length right) => Comparer<double>.Default.Compare(left.Value, right.Value) > 0;
+    [Pure] public static bool operator >(Length left, Length right) => Comparer<double>.Default.Compare(left._value, right._value) > 0;
 
     /// <summary>
     /// Less than or equal operator to compare two Length objects
@@ -238,7 +250,7 @@ public override readonly bool Equals(object obj)
     /// <param name="left">left value</param>
     /// <param name="right">right value</param>
     /// <returns>true if left is less than or equal to right</returns>
-    [Pure] public static bool operator <=(Length left, Length right) => Comparer<double>.Default.Compare(left.Value, right.Value) <= 0;
+    [Pure] public static bool operator <=(Length left, Length right) => Comparer<double>.Default.Compare(left._value, right._value) <= 0;
 
     /// <summary>
     /// Greater than or equal operator to compare two Length objects
@@ -246,7 +258,7 @@ public override readonly bool Equals(object obj)
     /// <param name="left">left value</param>
     /// <param name="right">right value</param>
     /// <returns>true if left is greater than or equal to right</returns>
-    [Pure] public static bool operator >=(Length left, Length right) => Comparer<double>.Default.Compare(left.Value, right.Value) >= 0;
+    [Pure] public static bool operator >=(Length left, Length right) => Comparer<double>.Default.Compare(left._value, right._value) >= 0;
 
     // Math
     /// <summary>
@@ -255,7 +267,7 @@ public override readonly bool Equals(object obj)
     /// <param name="left">left value</param>
     /// <param name="right">right value</param>
     /// <returns>A new Length object with a value of left + right</returns>
-    [Pure] public static Length operator +(Length left, Length right) => new(left.Value + right.Value);
+    [Pure] public static Length operator +(Length left, Length right) => new(left._value + right._value);
 
     /// <summary>
     /// Subtraction operator to subtract two Length objects
@@ -263,7 +275,7 @@ public override readonly bool Equals(object obj)
     /// <param name="left">left value</param>
     /// <param name="right">right value</param>
     /// <returns>A new Length object with a value of left - right</returns>
-    [Pure] public static Length operator -(Length left, Length right) => new(left.Value - right.Value);
+    [Pure] public static Length operator -(Length left, Length right) => new(left._value - right._value);
 
     /// <summary>
     /// Multiplication operator to multiply by a double
@@ -271,7 +283,7 @@ public override readonly bool Equals(object obj)
     /// <param name="value">object to multiply</param>
     /// <param name="operand">operand to multiply object</param>
     /// <returns>A new Length object with a value of value multiplied by the operand</returns>
-    [Pure] public static Length operator *(Length value, double operand) => new(value.Value * operand);
+    [Pure] public static Length operator *(Length value, double operand) => new(value._value * operand);
 
     /// <summary>
     /// Division operator to divide by a double
@@ -279,19 +291,19 @@ public override readonly bool Equals(object obj)
     /// <param name="value">object to be divided</param>
     /// <param name="operand">operand to divide object</param>
     /// <returns>A new Length object with a value of value divided by the operand</returns>
-    [Pure] public static Length operator /(Length value, double operand) => new(value.Value / operand);
+    [Pure] public static Length operator /(Length value, double operand) => new(value._value / operand);
 
     /// <summary>
     /// Returns the absolute value of the <see cref="Length"/>
     /// </summary>
     /// <returns></returns>
-    [Pure] public readonly Length Abs() { return new Length(Math.Abs(this.Value)); }
+    [Pure] public readonly Length Abs() { return new Length(Math.Abs(this._value)); }
 
     /// <summary>
     /// Get a string representation of the object
     /// </summary>
     /// <returns>A string representing the object</returns>
-    [Pure] public override readonly string ToString() => Value.ToString();
+    [Pure] public override readonly string ToString() => _value.ToString();
 
     /// <summary>
     /// Get a string representation of the object
@@ -299,7 +311,7 @@ public override readonly bool Equals(object obj)
     /// <param name="format">format</param>
     /// <param name="formatProvider">format provider</param>
     /// <returns>A string representing the object</returns>
-    [Pure] public readonly string ToString(string format, IFormatProvider formatProvider) => Value.ToString(format, formatProvider);
+    [Pure] public readonly string ToString(string format, IFormatProvider formatProvider) => _value.ToString(format, formatProvider);
 
     // IComparable
     /// <summary>
@@ -307,97 +319,97 @@ public override readonly bool Equals(object obj)
     /// </summary>
     /// <param name="obj">The other Length cast to object</param>
     /// <returns>0 if equal</returns>
-    [Pure] public readonly int CompareTo(object obj) => Value.CompareTo(obj);
+    [Pure] public readonly int CompareTo(object obj) => _value.CompareTo(obj);
 
     /// <summary>
     /// Get type code of object
     /// </summary>
     /// <returns>The TypeCode</returns>
-    [Pure] public readonly TypeCode GetTypeCode() => Value.GetTypeCode();
+    [Pure] public readonly TypeCode GetTypeCode() => _value.GetTypeCode();
 
     /// <summary>
     /// Convert to boolean
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>bool representation of the object</returns>
-    [Pure] public readonly bool ToBoolean(IFormatProvider provider) => ((IConvertible)Value).ToBoolean(provider);
+    [Pure] public readonly bool ToBoolean(IFormatProvider provider) => ((IConvertible)_value).ToBoolean(provider);
 
     /// <summary>
     /// Convert to byte
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>byte representation of the object</returns>
-    [Pure] public readonly byte ToByte(IFormatProvider provider) => ((IConvertible)Value).ToByte(provider);
+    [Pure] public readonly byte ToByte(IFormatProvider provider) => ((IConvertible)_value).ToByte(provider);
 
     /// <summary>
     /// Convert to char
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>char representation of the object</returns>
-    [Pure] public readonly char ToChar(IFormatProvider provider) => ((IConvertible)Value).ToChar(provider);
+    [Pure] public readonly char ToChar(IFormatProvider provider) => ((IConvertible)_value).ToChar(provider);
 
     /// <summary>
     /// Convert to DateTime
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>DateTime representation of the object</returns>
-    [Pure] public readonly DateTime ToDateTime(IFormatProvider provider) => ((IConvertible)Value).ToDateTime(provider);
+    [Pure] public readonly DateTime ToDateTime(IFormatProvider provider) => ((IConvertible)_value).ToDateTime(provider);
 
     /// <summary>
     /// Convert to Decimal
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>Decimal representation of the object</returns>
-    [Pure] public readonly decimal ToDecimal(IFormatProvider provider) => ((IConvertible)Value).ToDecimal(provider);
+    [Pure] public readonly decimal ToDecimal(IFormatProvider provider) => ((IConvertible)_value).ToDecimal(provider);
 
     /// <summary>
     /// Convert to double
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>double representation of the object</returns>
-    [Pure] public readonly double ToDouble(IFormatProvider provider) => Value;
+    [Pure] public readonly double ToDouble(IFormatProvider provider) => _value;
 
     /// <summary>
     /// Convert to in16
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>int16 representation of the object</returns>
-    [Pure] public readonly short ToInt16(IFormatProvider provider) => ((IConvertible)Value).ToInt16(provider);
+    [Pure] public readonly short ToInt16(IFormatProvider provider) => ((IConvertible)_value).ToInt16(provider);
 
     /// <summary>
     /// Convert to int32
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>int32 representation of the object</returns>
-    [Pure] public readonly int ToInt32(IFormatProvider provider) => ((IConvertible)Value).ToInt32(provider);
+    [Pure] public readonly int ToInt32(IFormatProvider provider) => ((IConvertible)_value).ToInt32(provider);
 
     /// <summary>
     /// Convert to int64
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>int64 representation of the object</returns>
-    [Pure] public readonly long ToInt64(IFormatProvider provider) => ((IConvertible)Value).ToInt64(provider);
+    [Pure] public readonly long ToInt64(IFormatProvider provider) => ((IConvertible)_value).ToInt64(provider);
 
     /// <summary>
     /// Convert to sbyte
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>sbyte representation of the object</returns>
-    [Pure] public readonly sbyte ToSByte(IFormatProvider provider) => ((IConvertible)Value).ToSByte(provider);
+    [Pure] public readonly sbyte ToSByte(IFormatProvider provider) => ((IConvertible)_value).ToSByte(provider);
 
     /// <summary>
     /// Convert to float
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>float representation of the object</returns>
-    [Pure] public readonly float ToSingle(IFormatProvider provider) => ((IConvertible)Value).ToSingle(provider);
+    [Pure] public readonly float ToSingle(IFormatProvider provider) => ((IConvertible)_value).ToSingle(provider);
 
     /// <summary>
     /// Convert to string
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>string representation of the object</returns>
-    [Pure] public readonly string ToString(IFormatProvider provider) => Value.ToString(provider);
+    [Pure] public readonly string ToString(IFormatProvider provider) => _value.ToString(provider);
 
     /// <summary>
     /// Convert to type
@@ -405,28 +417,28 @@ public override readonly bool Equals(object obj)
     /// <param name="conversionType">type to covert to</param>
     /// <param name="provider">format provider</param>
     /// <returns>type representation of the object</returns>
-    [Pure] public readonly object ToType(Type conversionType, IFormatProvider provider) => ((IConvertible)Value).ToType(conversionType, provider);
+    [Pure] public readonly object ToType(Type conversionType, IFormatProvider provider) => ((IConvertible)_value).ToType(conversionType, provider);
 
     /// <summary>
     /// Convert to uint16
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>uint16 representation of the object</returns>
-    [Pure] public readonly ushort ToUInt16(IFormatProvider provider) => ((IConvertible)Value).ToUInt16(provider);
+    [Pure] public readonly ushort ToUInt16(IFormatProvider provider) => ((IConvertible)_value).ToUInt16(provider);
 
     /// <summary>
     /// Convert to uint32
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>uint32 representation of the object</returns>
-    [Pure] public readonly uint ToUInt32(IFormatProvider provider) => ((IConvertible)Value).ToUInt32(provider);
+    [Pure] public readonly uint ToUInt32(IFormatProvider provider) => ((IConvertible)_value).ToUInt32(provider);
 
     /// <summary>
     /// Convert to uint64
     /// </summary>
     /// <param name="provider">format provider</param>
     /// <returns>uint64 representation of the object</returns>
-    [Pure] public readonly ulong ToUInt64(IFormatProvider provider) => ((IConvertible)Value).ToUInt64(provider);
+    [Pure] public readonly ulong ToUInt64(IFormatProvider provider) => ((IConvertible)_value).ToUInt64(provider);
 
     /// <summary>
     /// Compare the default value to a double 
@@ -436,7 +448,7 @@ public override readonly bool Equals(object obj)
     [Pure]
     public readonly int CompareTo(double? other)
     {
-        return (other is null) ? -1 : (Value).CompareTo(other.Value);
+        return (other is null) ? -1 : (_value).CompareTo(other.Value);
     }
 
     /// <summary>
@@ -444,19 +456,19 @@ public readonly int CompareTo(double? other)
     /// </summary>
     /// <param name="other">value to compare</param>
     /// <returns>0 if equal</returns>
-    [Pure] public readonly bool Equals(double? other) => Value.Equals(other);
+    [Pure] public readonly bool Equals(double? other) => _value.Equals(other);
 
     /// <summary>
     /// Compare the default value to a double 
     /// </summary>
     /// <param name="other">value to compare</param>
     /// <returns>0 if equal</returns>
-    [Pure] public readonly bool Equals(double other) => Value.Equals(other);
+    [Pure] public readonly bool Equals(double other) => _value.Equals(other);
 
     /// <summary>
     /// Compare the default value to a double 
     /// </summary>
     /// <param name="other">value to compare</param>
     /// <returns>0 if equal</returns>
-    [Pure] public readonly int CompareTo(double other) => Value.CompareTo(other);
+    [Pure] public readonly int CompareTo(double other) => _value.CompareTo(other);
 }
\ No newline at end of file