13,046,337 members (74,701 online)
Technical Blog
alternative version

#### Stats

11.3K views
8 bookmarked
Posted 6 Jan 2012

# A C# Temperature Struct

, 6 Jan 2012
 Rate this:
A temperature struct in C#

Microsoft loves using temperature in .NET examples. See here and here.

So, I decided to combine them all into a nice structure that implements `IFormattable`, `IComparable`, `IEquatable`<t>, etc. That way, they don't have to keep rewriting it themselves.

The code also gives some good examples on operator overloading. Have fun.

```using System;
using System.Globalization;

/// <summary>
/// Options for temperature measurement units.
/// </summary>
public enum TemperatureUnit
{
/// <summary>
/// The SI base unit of thermodynamic temperature,
/// equal in magnitude to the degree Celsius.
/// </summary>
Kelvin,

/// <summary>
/// A scale of temperature on which water freezes
/// at 0° and boils at 100° under standard conditions.
/// </summary>
Celsius,

/// <summary>
/// A scale of temperature on which water freezes at 32°
/// and boils at 212° under standard conditions.
/// </summary>
Fahrenheit
}

/// <summary>
/// A temperature value.
/// </summary>
public struct Temperature : IFormattable, IComparable,
IComparable<Temperature>, IEquatable<Temperature>
{
private double _Kelvin;

/// <summary>
/// Creates a new temperature with the specified value in Kelvin.
/// </summary>
/// <param name="kelvin">The value of the temperature.</param>
public Temperature(double kelvin) : this() { _Kelvin = kelvin; }

/// <summary>
/// Creates a new temperature with the specified value in the
/// specified unit of measurement.
/// </summary>
/// <param name="temperature">The value of the temperature.</param>
/// <param name="unit">The unit of measurement that defines how
/// the <paramref name="temperature"/> value is used.</param>
public Temperature(double temperature, TemperatureUnit unit)
: this()
{
switch (unit)
{
case TemperatureUnit.Kelvin:
_Kelvin = temperature;
break;
case TemperatureUnit.Celsius:
Celsius = temperature;
break;
case TemperatureUnit.Fahrenheit:
Fahrenheit = temperature;
break;
default:
throw new ArgumentException(
"The temperature unit '" + unit.ToString() + "' is unknown.");
}
}

/// <summary>
/// Gets or sets the temperature value in Kelvin.
/// </summary>
public double Kelvin
{
get { return _Kelvin; }
set { _Kelvin = value; }
}

/// <summary>
/// Gets or sets the temperature value in Celsius.
/// </summary>
public double Celsius
{
get { return KelvinToCelsius(_Kelvin); }
set { _Kelvin = CelsiusToKelvin(value); }
}

/// <summary>
/// Gets or sets the temperature value in Fahrenheit.
/// </summary>
public double Fahrenheit
{
get { return KelvinToFahrenheit(_Kelvin); }
set { _Kelvin = FahrenheitToKelvin(value); }
}

/// <summary>
/// Gets the temperature value in the specified unit of measurement.
/// </summary>
/// <param name="unit">The unit of measurement
/// in which the temperature should be retrieved.</param>
/// <returns>The temperature value in the specified
/// <paramref name="unit"/>.</returns>
public double ValueIn(TemperatureUnit unit)
{
switch (unit)
{
case TemperatureUnit.Kelvin: return _Kelvin;
case TemperatureUnit.Celsius: return Celsius;
case TemperatureUnit.Fahrenheit: return Fahrenheit;
default: throw new ArgumentException(
"Unknown temperature unit '" + unit.ToString() + "'.");
}
}

/// <summary>
/// Returns a string representation of the temperature value.
/// </summary>
/// <param name="format">
/// A single format specifier that indicates how to format the value of this
/// temperature. The format parameter can be "G",
/// "C", "F", or "K". If format
/// is null or the empty string (""), "G" is used.
/// </param>
/// <param name="provider">
/// An IFormatProvider reference that supplies culture-specific formatting
/// services.
/// </param>
/// <returns>A string representation of the temperature.</returns>
/// <exception cref="FormatException">
/// The value of format is not null, the empty string (""), "G", "C", "F", or
/// "K".
/// </exception>
public string ToString(string format, IFormatProvider provider)
{
if (String.IsNullOrEmpty(format)) format = "G";
if (provider == null) provider = CultureInfo.CurrentCulture;

switch (format.ToUpperInvariant())
{
case "G":
case "C":
return Celsius.ToString("F2", provider) + " °C";
case "F":
return Fahrenheit.ToString("F2", provider) + " °F";
case "K":
return _Kelvin.ToString("F2", provider) + " K";
default:
throw new FormatException(
String.Format("The {0} format string is not supported.", format));
}
}

/// <summary>
/// Returns a string representation of the temperature value.
/// </summary>
/// <param name="format">
/// A single format specifier that indicates how to format the value of this
/// temperature. The format parameter can be "G",
/// "C", "F", or "K". If format
/// is null or the empty string (""), "G" is used.
/// </param>
/// <returns>A string representation of the temperature.</returns>
/// <exception cref="FormatException">
/// The value of format is not null,
/// the empty string (""), "G", "C", "F", or
/// "K".
/// </exception>
public string ToString(string format)
{
}

/// <summary>
/// Returns a string representation of the temperature value.
/// </summary>
/// <returns>A string representation of the temperature.</returns>
public override string ToString()
{
}

/// <summary>
/// Returns a string representation of the temperature value.
/// </summary>
/// <param name="unit">
/// The temperature unit as which the temperature value should be displayed.
/// </param>
/// <param name="provider">
/// An IFormatProvider reference that supplies culture-specific formatting
/// services.
/// </param>
/// <returns>A string representation of the temperature.</returns>
public string ToString(TemperatureUnit unit, IFormatProvider provider)
{
switch (unit)
{
case TemperatureUnit.Celsius:
case TemperatureUnit.Fahrenheit:
case TemperatureUnit.Kelvin:
default:
throw new FormatException("The temperature unit '" +
unit.ToString() + "' is unknown.");
}
}

/// <summary>
/// Returns a string representation of the temperature value.
/// </summary>
/// <param name="unit">
/// The temperature unit as which the temperature value should be displayed.
/// </param>
/// <returns>A string representation of the temperature.</returns>
public string ToString(TemperatureUnit unit)
{
}

/// <summary>
/// Compares this instance to a specified Temperature object and returns an indication
/// of their relative values.
/// </summary>
/// <param name="value">A Temperature object
///    to compare to this instance.</param>
/// <returns>
/// A signed number indicating the relative values of this instance and value.
/// Value Description A negative integer This instance is less than value. Zero
/// This instance is equal to value. A positive integer This instance is greater
/// than value.
/// </returns>
public int CompareTo(Temperature value)
{
return _Kelvin.CompareTo(value._Kelvin);
}

/// <summary>
/// Compares this instance to a specified object and returns an indication of
/// their relative values.
/// </summary>
/// <param name="value">An object to compare, or null.</param>
/// <returns>
/// A signed number indicating the relative values of this instance and value.
/// Value Description A negative integer This instance is less than value. Zero
/// This instance is equal to value. A positive integer This instance is greater
/// than value, or value is null.
/// </returns>
/// <exception cref="ArgumentException">
/// The value is not a Temperature.
/// </exception>
public int CompareTo(object value)
{
if (value == null) return 1;
if (!(value is Temperature)) throw new ArgumentException();
return CompareTo((Temperature)value);
}

/// <summary>
/// Determines whether or not the given temperature is considered equal to this instance.
/// </summary>
/// <param name="value">The temperature to compare to this instance.</param>
/// <returns>True if the temperature is considered equal
///    to this instance. Otherwise, false.</returns>
public bool Equals(Temperature value)
{
return _Kelvin == value._Kelvin;
}

/// <summary>
/// Determines whether or not the given object is considered equal to the temperature.
/// </summary>
/// <param name="value">The object to compare to the temperature.</param>
/// <returns>True if the object is considered equal
///     to the temperature. Otherwise, false.</returns>
public override bool Equals(object value)
{
if (value == null) return false;
if (!(value is Temperature)) return false;

return Equals((Temperature)value);
}

/// <summary>
/// Returns the hash code for this instance.
/// </summary>
/// <returns>A 32-bit signed integer hash code.</returns>
public override int GetHashCode()
{
return _Kelvin.GetHashCode();
}

/// <summary>
/// Determines the equality of two temperatures.
/// </summary>
/// <param name="t1">The first temperature to be compared.</param>
/// <param name="t2">The second temperature to be compared.</param>
/// <returns>True if the temperatures are equal. Otherwise, false.</returns>
public static bool operator ==(Temperature t1, Temperature t2)
{
return t1.Equals(t2);
}

/// <summary>
/// Determines the inequality of two temperatures.
/// </summary>
/// <param name="t1">The first temperature to be compared.</param>
/// <param name="t2">The second temperature to be compared.</param>
/// <returns>True if the temperatures are NOT equal. Otherwise, false.</returns>
public static bool operator !=(Temperature t1, Temperature t2)
{
return !t1.Equals(t2);
}

/// <summary>
/// Determines whether one temperature is considered greater than another.
/// </summary>
/// <param name="t1">The first temperature to be compared.</param>
/// <param name="t2">The second temperature to be compared.</param>
/// <returns>True if the first temperature is greater than the second.
/// Otherwise, false.</returns>
public static bool operator >(Temperature t1, Temperature t2)
{
return t1._Kelvin > t2._Kelvin;
}

/// <summary>
/// Determines whether one temperature is considered less than another.
/// </summary>
/// <param name="t1">The first temperature to be compared.</param>
/// <param name="t2">The second temperature to be compared.</param>
/// <returns>True if the first temperature is less than the second.
/// Otherwise, false.</returns>
public static bool operator <(Temperature t1, Temperature t2)
{
return t1._Kelvin < t2._Kelvin;
}

/// <summary>
/// Determines whether one temperature is considered greater to or equal to another.
/// </summary>
/// <param name="t1">The first temperature to be compared.</param>
/// <param name="t2">The second temperature to be compared.</param>
/// <returns>
/// True if the first temperature is greater to or equal to the second. Otherwise, false.
/// </returns>
public static bool operator >=(Temperature t1, Temperature t2)
{
return t1._Kelvin >= t2._Kelvin;
}

/// <summary>
/// Determines whether one temperature is considered less than or equal to another.
/// </summary>
/// <param name="t1">The first temperature to be compared.</param>
/// <param name="t2">The second temperature to be compared.</param>
/// <returns>
/// True if the first temperature is less than or equal to the second. Otherwise, false.
/// </returns>
public static bool operator <=(Temperature t1, Temperature t2)
{
return t1._Kelvin <= t2._Kelvin;
}

/// <summary>
/// Adds two instances of the temperature object.
/// </summary>
/// <param name="t1">The temperature on the left-hand side of the operator.
/// </param>
/// <param name="t2">The temperature on the right-hand side of the operator.
/// </param>
/// <returns>The sum of the two temperatures.</returns>
public static Temperature operator +(Temperature t1, Temperature t2)
{
return new Temperature(t1._Kelvin + t2._Kelvin);
}

/// <summary>
/// Subtracts one instance from another.
/// </summary>
/// <param name="t1">The temperature on the left-hand side of the operator.
/// </param>
/// <param name="t2">The temperature on the right-hand side of the operator.
/// </param>
/// <returns>The difference of the two temperatures.</returns>
public static Temperature operator -(Temperature t1, Temperature t2)
{
return new Temperature(t1._Kelvin - t2._Kelvin);
}

/// <summary>
/// Multiplies two instances of the temperature object.
/// </summary>
/// <param name="t1">The temperature on the left-hand side of the operator.
/// </param>
/// <param name="t2">The temperature on the right-hand side of the operator.
/// </param>
/// <returns>The product of the two temperatures.</returns>
public static Temperature operator *(Temperature t1, Temperature t2)
{
return new Temperature(t1._Kelvin * t2._Kelvin);
}

/// <summary>
/// Divides one instance of a temperature object by another.
/// </summary>
/// <param name="t1">The temperature on the left-hand side of the operator.
/// </param>
/// <param name="t2">The temperature on the right-hand side of the operator.
/// </param>
/// <returns>The quotient of the two temperature.</returns>
public static Temperature operator /(Temperature t1, Temperature t2)
{
// TODO: Throw a divide-by-zero exception if needed.
return new Temperature(t1._Kelvin / t2._Kelvin);
}

/// <summary>
/// Finds the remainder when one instance of a temperature object is divided by another.
/// </summary>
/// <param name="t1">The temperature on the left-hand side of the operator.
/// </param>
/// <param name="t2">The temperature on the right-hand side of the operator.
/// </param>
/// <returns>The remainder after the quotient is found.</returns>
public static Temperature operator %(Temperature t1, Temperature t2)
{
// TODO: Throw a divide-by-zero exception if needed.
return new Temperature(t1._Kelvin % t2._Kelvin);
}

/// <summary>
/// Converts a Kelvin temperature value to Celsius.
/// </summary>
/// <param name="kelvin">The Kelvin value to convert to Celsius.
/// </param>
/// <returns>The Kelvin value in Celsius.</returns>
public static double KelvinToCelsius(double kelvin)
{
return kelvin - 273.15;
}

/// <summary>
/// Converts a Celsius value to Kelvin.
/// </summary>
/// <param name="celsius">The Celsius value to convert to Kelvin.
/// </param>
/// <returns>The Celsius value in Kelvin.</returns>
public static double CelsiusToKelvin(double celsius)
{
return celsius + 273.15;
}

/// <summary>
/// Converts a Kelvin value to Fahrenheit.
/// </summary>
/// <param name="kelvin">The Kelvin value to convert to Fahrenheit.
/// </param>
/// <returns>The Kelvin value in Fahrenheit.</returns>
public static double KelvinToFahrenheit(double kelvin)
{
return kelvin * 9 / 5 - 459.67;
}

/// <summary>
/// Converts a Fahrenheit value to Kelvin.
/// </summary>
/// <param name="fahrenheit">The Fahrenheit value to convert to Kelvin.
/// </param>
/// <returns>The Fahrenheit value in Kelvin.</returns>
public static double FahrenheitToKelvin(double fahrenheit)
{
return (fahrenheit + 459.67) * 5 / 9;
}

/// <summary>
/// Converts a Fahrenheit value to Celsius.
/// </summary>
/// <param name="fahrenheit">The Fahrenheit value to convert to Celsius.
/// </param>
/// <returns>The Fahrenheit value in Celsius.</returns>
public static double FahrenheitToCelsius(double fahrenheit)
{
return (fahrenheit - 32) * 5 / 9;
}

/// <summary>
/// Converts a Celsius value to Fahrenheit.
/// </summary>
/// <param name="celsius">The Celsius value to convert to Fahrenheit.
/// </param>
/// <returns>The Celsius value in Fahrenheit.</returns>
public static double CelsiusToFahrenheit(double celsius)
{
return celsius * 9 / 5 + 32;
}
}```

## Share

 Engineer United States
No Biography provided

## You may also be interested in...

 First Prev Next
 Arithmetic operator overloads. supercat96-Jan-12 12:48 supercat9 6-Jan-12 12:48
 Re: Arithmetic operator overloads. qenn12-Jan-12 9:01 qenn 12-Jan-12 9:01
 Last Visit: 31-Dec-99 18:00     Last Update: 23-Jul-17 11:48 Refresh 1