/// <summary> /// Increases a specified variable by one and stores the result as an atomic operation. /// </summary> /// <param name="target">The shared object whose property is to be incremented.</param> /// <param name="propertyName">The property on that object to be incremented.</param> /// <param name="callback">The action to be run when the asynchronous operation completes.</param> public void Increment(INotifyPropertyChanged target, string propertyName, Action <int> callback) { InterlockedPropertyInfo propInfo = GetPropertyInfo(target, propertyName, typeof(int)); Action <long> longCallback = l => callback((int)l); this.SendPayload(propInfo, AtomicOperators.Add, longCallback, 1L); }
/// <summary> /// Compares two shared objects for equality and, if they are equal, replaces the target value, returning the result in the callback. /// </summary> /// <param name="target">The destination object, whose property value is compared with <see cref="comparand"/> and possibly replaced.</param> /// <param name="value">The value to replace the <see cref="target"/>'s property value if the comparison results in equality.</param> /// <param name="comparand">The value that is compared to the property value at the destination object.</param> /// <param name="propertyName">The name of the property on the destination object whose value is compared with <see cref="comparand"/> and possibly replaced.</param> /// <param name="callback">The action to be issued when the asynchronous operation completes.</param> public void CompareExchange(INotifyPropertyChanged target, string propertyName, int value, int comparand, Action <int> callback) { InterlockedPropertyInfo propInfo = GetPropertyInfo(target, propertyName, typeof(int)); Action <long> longCallback = l => callback((int)l); this.SendPayload(propInfo, AtomicOperators.CompareExchange, longCallback, (long)value, (long)comparand); }
// Send method for operations with callbacks. Store the callback in a queue for retrieval upon completion of server operation. private void SendPayload <T>(InterlockedPropertyInfo propInfo, AtomicOperators operation, Action <T> callback, params T[] parameters) { AtomicPayload payload = new AtomicPayload ( this.Client.ClientId, propInfo.ObjectId, propInfo.Property.Index, propInfo.PropertyType.AssemblyQualifiedName, operation, parameters.Select(p => Json.WriteObject(p)).ToArray() ); // For operations with callbacks, we need to create an async result and queue it up for retrieval when the server operation completes if (callback != null) { var getResult = new SharedAsyncResult <T>(EndSendAtomicPayload <T>, payload.PayloadId, callback); this.Client.EnqueueAsyncResult(getResult, payload.PayloadId); } this.Client.SendPublishEvent(payload); }
/// <summary> /// Decreases a specified variable by one and stores the result as an atomic operation. /// </summary> /// <param name="target">The shared object whose property is to be decremeneted.</param> /// <param name="propertyName">The property on that object to be decremented.</param> public void Decrement(INotifyPropertyChanged target, string propertyName) { InterlockedPropertyInfo propInfo = GetPropertyInfo(target, propertyName, typeof(long), typeof(int)); this.SendPayload(propInfo, AtomicOperators.Add, null, -1L); }
/// <summary> /// Compares two shared objects for equality and, if they are equal, replaces the target value, returning the result in the callback. /// </summary> /// <param name="target">The destination object, whose property value is compared with <see cref="comparand"/> and possibly replaced.</param> /// <param name="value">The value to replace the <see cref="target"/>'s property value if the comparison results in equality.</param> /// <param name="comparand">The value that is compared to the property value at the destination object.</param> /// <param name="propertyName">The name of the property on the destination object whose value is compared with <see cref="comparand"/> and possibly replaced.</param> /// <param name="callback">The action to be issued when the asynchronous operation completes.</param> public void CompareExchange(INotifyPropertyChanged target, string propertyName, string value, string comparand, Action <string> callback) { InterlockedPropertyInfo propInfo = GetPropertyInfo(target, propertyName, typeof(string)); this.SendPayload(propInfo, AtomicOperators.CompareExchange, callback, value, comparand); }
/// <summary> /// Adds two 64-bit integers and replaces the first integer with the sum as an atomic operation. /// </summary> /// <param name="target">The shared object whose property is to be added.</param> /// <param name="propertyName">The property on that Int64 to be added.</param> /// <param name="value">The value to add on to the target's property.</param> /// <param name="callback">The action to be run when the asynchronous operation completes.</param> public void Add(INotifyPropertyChanged target, string propertyName, long value, Action <long> callback) { InterlockedPropertyInfo propInfo = GetPropertyInfo(target, propertyName, typeof(long)); this.SendPayload(propInfo, AtomicOperators.Add, callback, value); }
/// <summary> /// Adds two integers and replaces the first integer with the sum as an atomic operation. /// </summary> /// <param name="target">The shared object whose property is to be added.</param> /// <param name="propertyName">The property on that Int32 to be added.</param> /// <param name="value">The value to add on to the target's property.</param> public void Add(INotifyPropertyChanged target, string propertyName, int value) { InterlockedPropertyInfo propInfo = GetPropertyInfo(target, propertyName, typeof(int), typeof(long)); this.SendPayload(propInfo, AtomicOperators.Add, null, (long)value); }