/// <summary> /// Tries to asynchronously receives a value from a specified source. /// </summary> /// <typeparam name="TOutput">The type of data contained in the source to receive.</typeparam> /// <param name="source">The source from which to receive the value.</param> /// <param name="timeout"> /// The maximum time interval, in milliseconds, to wait for the synchronous operation to complete, /// or an interval that represents -1 milliseconds to wait indefinitely. /// </param> /// <returns> /// A task that represents the asynchronous receive operation. When an item value is successfully received from the source, /// the returned task is completed and its <see cref="Task{T}.Result"/> returns a successful <see cref="TryValue{TOutput}"/> /// containing the received value. If an item value cannot be retrieved because the source is empty and completed, the returned /// task is completed and its <see cref="Task{T}.Result"/> returns <see cref="TryValue.None()"/>. /// </returns> public static async Task <TryValue <TOutput> > TryReceiveAsync <TOutput>( this ISourceBlock <TOutput> source, TimeSpan timeout) { Contracts.Requires.That(source != null); Contracts.Requires.That(timeout.IsDuration()); try { return(TryValue.New(await source.ReceiveAsync(timeout).DontMarshallContext())); } catch (InvalidOperationException) { return(TryValue.None <TOutput>()); } }
public static TryValue <T> TryDeserialize <T>(this IValueKey <T> key, string value) { Contracts.Requires.That(key != null); T result; if (key.TryDeserialize(value, out result)) { return(TryValue.New(result)); } else { return(TryValue.None <T>()); } }
public static async Task <TryValue <ReleaseStruct> > TryWaitForUsingBlockAsync( this SemaphoreSlim semaphore, TimeSpan timeout, CancellationToken cancellation = default(CancellationToken)) { Contracts.Requires.That(semaphore != null); Contracts.Requires.That(Time.IsDuration(timeout)); if (await semaphore.WaitAsync(timeout, cancellation).DontMarshallContext()) { return(TryValue.New(new ReleaseStruct(semaphore))); } else { return(TryValue.None <ReleaseStruct>()); } }
/// <inheritdoc /> public TValue this[TIndex index] { // this method's contracts will check that the dictionary contains the key first get { IDictionaryContracts.IndexerGet(this, index); IReadOnlyIndexableContracts.IndexerGet(this, index); return(this.indexable[index].Value); } set { IDictionaryContracts.IndexerSet(this, index); IIndexableContracts.IndexerSet(this, index); if (!this.indexable[index].HasValue) { this.count++; } this.indexable[index] = TryValue.New(value); } }
public static TryValue <T> SingleOrNone <T>(this IEnumerable <T> values) { Contracts.Requires.That(values != null); return(values.IsEmpty() ? TryValue.None <T>() : TryValue.New(values.Single())); }
public static TryValue <T> ElementAtOrNone <T>(this IEnumerable <T> values, int index) { Contracts.Requires.That(values != null); Contracts.Requires.That(index >= 0); var readOnlyList = values as IReadOnlyList <T>; if (readOnlyList != null) { return(index.IsIn(readOnlyList.GetIndexRange()) ? TryValue.New(readOnlyList[index]) : TryValue.None <T>()); } var list = values as IList <T>; if (list != null) { return(index.IsIn(list.GetListIndexRange()) ? TryValue.New(list[index]) : TryValue.None <T>()); } int count = 0; foreach (var value in values) { if (count == index) { return(TryValue.New(value)); } count++; } return(TryValue.None <T>()); }