/// <summary>
/// Decrease the property's value by one, and also return the newly decreased value, all in one atomic operation.
/// </summary>
/// <returns>The new, lower value, which is also the property's new value.</returns>
public static long Decrement(this StoredProperty <long> storedProperty)
{
long newValue = Interlocked.Decrement(ref storedProperty.StoredValue);
storedProperty.OnValueChanged(newValue + 1, newValue);
return(newValue);
}
/// <summary>
/// Decrease the property's value by one, and also return the newly decreased value, all in one atomic operation.
/// </summary>
/// <returns>The new, lower value, which is also the property's new value.</returns>
public static int Decrement(this StoredProperty <int> storedProperty)
{
int newValue = Interlocked.Decrement(ref storedProperty.StoredValue);
storedProperty.OnValueChanged(newValue + 1, newValue);
return(newValue);
}
/// <summary>
/// Set the property to a new value, and also get the old value, in one atomic operation.
/// </summary>
/// <param name="storedProperty"></param>
/// <param name="newValue">The new value to set on the property</param>
/// <returns>The old value of the property</returns>
public static int Exchange(this StoredProperty <int> storedProperty, int newValue)
{
int oldValue = Interlocked.Exchange(ref storedProperty.StoredValue, newValue);
if (oldValue != newValue)
{
storedProperty.OnValueChanged(oldValue, newValue);
}
return(oldValue);
}
/// <summary>
/// Increase the property's value by a specified amount, and also return the new value, all in one atomic operation.
/// </summary>
/// <remarks>There is no Subtract() method, but you can pass a negative number to <c>Add()</c> instead.</remarks>
/// <returns>The new value, which is also the property's new value.</returns>
public static long Add(this StoredProperty <long> storedProperty, long value)
{
long newValue = Interlocked.Add(ref storedProperty.StoredValue, value);
if (value != 0)
{
storedProperty.OnValueChanged(newValue - value, newValue);
}
return(newValue);
}
/// <summary>
/// Increase the property's value by a specified amount, and also return the new value, all in one atomic operation.
/// </summary>
/// <remarks>There is no Subtract() method, but you can pass a negative number to <c>Add()</c> instead.</remarks>
/// <returns>The new value, which is also the property's new value.</returns>
public static int Add(this StoredProperty <int> storedProperty, int value)
{
int newValue = Interlocked.Add(ref storedProperty.StoredValue, value);
if (value != 0)
{
storedProperty.OnValueChanged(newValue - value, newValue);
}
return(newValue);
}
/// <summary>
/// Compare the property's value to a comparison value. If they are equal, set the property's value to a new value.
/// </summary>
/// <param name="storedProperty"></param>
/// <param name="newValueToAssign">The property's value may be set to this new value</param>
/// <param name="onlyExchangeIfPropertyValueEquals">The property's value will be compared to this value</param>
/// <returns>The old value of the property, whether or not the property value changed</returns>
public static T CompareExchange <T>(this StoredProperty <T> storedProperty, T newValueToAssign, T onlyExchangeIfPropertyValueEquals) where T : class
{
T oldValue = Interlocked.CompareExchange(ref storedProperty.StoredValue, newValueToAssign, onlyExchangeIfPropertyValueEquals);
if (oldValue != newValueToAssign)
{
storedProperty.OnValueChanged(oldValue, newValueToAssign);
}
return(oldValue);
}
/// <summary>
/// Compare the property's value to a comparison value. If they are equal, set the property's value to a new value.
/// </summary>
/// <param name="storedProperty"></param>
/// <param name="newValueToAssign">The property's value may be set to this new value</param>
/// <param name="onlyExchangeIfPropertyValueEquals">The property's value will be compared to this value</param>
/// <param name="changeTolerance">How different the old and new value have to be for a change event to be fired</param>
/// <returns>The old value of the property, whether or not the property value changed</returns>
public static double CompareExchange(this StoredProperty <double> storedProperty, double newValueToAssign, double onlyExchangeIfPropertyValueEquals, double changeTolerance = 0.0001)
{
double oldValue = Interlocked.CompareExchange(ref storedProperty.StoredValue, newValueToAssign, onlyExchangeIfPropertyValueEquals);
if (Math.Abs(oldValue - newValueToAssign) > changeTolerance)
{
storedProperty.OnValueChanged(oldValue, newValueToAssign);
}
return(oldValue);
}
/// <summary>
/// Compare the property's value to a comparison value. If they are equal, set the property's value to a new value.
/// </summary>
/// <param name="storedProperty"></param>
/// <param name="newValueToAssign">The property's value may be set to this new value</param>
/// <param name="onlyExchangeIfPropertyValueEquals">The property's value will be compared to this value</param>
/// <returns>The old value of the property, whether or not the property value changed</returns>
public static object CompareExchange(this StoredProperty <object> storedProperty, object newValueToAssign, object onlyExchangeIfPropertyValueEquals)
{
object oldValue = Interlocked.CompareExchange(ref storedProperty.StoredValue, newValueToAssign, onlyExchangeIfPropertyValueEquals);
if (oldValue != newValueToAssign)
{
storedProperty.OnValueChanged(oldValue, newValueToAssign);
}
return(oldValue);
}
/// <summary>
/// Compare the property's value to a comparison value. If they are equal, set the property's value to a new value.
/// </summary>
/// <param name="storedProperty"></param>
/// <param name="newValueToAssign">The property's value may be set to this new value</param>
/// <param name="onlyExchangeIfPropertyValueEquals">The property's value will be compared to this value</param>
/// <returns>The old value of the property, whether or not the property value changed</returns>
public static long CompareExchange(this StoredProperty <long> storedProperty, long newValueToAssign, long onlyExchangeIfPropertyValueEquals)
{
long oldValue = Interlocked.CompareExchange(ref storedProperty.StoredValue, newValueToAssign, onlyExchangeIfPropertyValueEquals);
if (oldValue != newValueToAssign)
{
storedProperty.OnValueChanged(oldValue, newValueToAssign);
}
return(oldValue);
}
/// <summary>
/// Set the property to a new value, and also get the old value, in one atomic operation.
/// </summary>
/// <param name="storedProperty"></param>
/// <param name="newValue">The new value to set on the property</param>
/// <returns>The old value of the property</returns>
public static T Exchange <T>(this StoredProperty <T> storedProperty, T newValue) where T : class
{
T oldValue = Interlocked.Exchange(ref storedProperty.StoredValue, newValue);
if (oldValue != newValue)
{
storedProperty.OnValueChanged(oldValue, newValue);
}
return(oldValue);
}
/// <summary>
/// Set the property to a new value, and also get the old value, in one atomic operation.
/// </summary>
/// <param name="storedProperty"></param>
/// <param name="newValue">The new value to set on the property</param>
/// <returns>The old value of the property</returns>
public static object Exchange(this StoredProperty <object> storedProperty, object newValue)
{
object oldValue = Interlocked.Exchange(ref storedProperty.StoredValue, newValue);
if (oldValue != newValue)
{
storedProperty.OnValueChanged(oldValue, newValue);
}
return(oldValue);
}
/// <summary>
/// Set the property to a new value, and also get the old value, in one atomic operation.
/// </summary>
/// <param name="storedProperty"></param>
/// <param name="newValue">The new value to set on the property</param>
/// <param name="changeTolerance">How different the old and new value have to be for a change event to be fired</param>
/// <returns>The old value of the property</returns>
public static double Exchange(this StoredProperty <double> storedProperty, double newValue, double changeTolerance = 0.0001)
{
double oldValue = Interlocked.Exchange(ref storedProperty.StoredValue, newValue);
if (Math.Abs(oldValue - newValue) > changeTolerance)
{
storedProperty.OnValueChanged(oldValue, newValue);
}
return(oldValue);
}
/// <summary>
/// Set the property to a new value, and also get the old value, in one atomic operation.
/// </summary>
/// <param name="storedProperty"></param>
/// <param name="newValue">The new value to set on the property</param>
/// <returns>The old value of the property</returns>
public static long Exchange(this StoredProperty <long> storedProperty, long newValue)
{
long oldValue = Interlocked.Exchange(ref storedProperty.StoredValue, newValue);
if (oldValue != newValue)
{
storedProperty.OnValueChanged(oldValue, newValue);
}
return(oldValue);
}