public async Task ValueAsyncDisposal()
{
var john = AsyncDisposableTestPerson.CreateJohn();
var emily = AsyncDisposableTestPerson.CreateEmily();
var options = new ActiveExpressionOptions();
options.AddExpressionValueDisposal(() => CombineAsyncDisposablePeople(null !, null !));
AsyncDisposableTestPerson?first, second;
var disposedTcs = new TaskCompletionSource <object?>();
using (var expr = ActiveExpression.Create(() => CombineAsyncDisposablePeople(john.Name !.Length > 3 ? john : emily, emily), options))
{
Assert.IsNull(expr.Fault);
first = expr.Value;
Assert.IsFalse(first !.IsDisposed);
first.Disposed += (sender, e) => disposedTcs.SetResult(null);
john.Name = string.Empty;
await Task.WhenAny(disposedTcs.Task, Task.Delay(TimeSpan.FromSeconds(1)));
Assert.IsNull(expr.Fault);
second = expr.Value;
Assert.IsFalse(second !.IsDisposed);
Assert.IsTrue(first.IsDisposed);
disposedTcs = new TaskCompletionSource <object?>();
second.Disposed += (sender, e) => disposedTcs.SetResult(null);
}
await Task.WhenAny(disposedTcs.Task, Task.Delay(TimeSpan.FromSeconds(1)));
Assert.IsTrue(second.IsDisposed);
}
public void SelectorsOptions()
{
var people = TestPerson.CreatePeopleCollection();
var options = new ActiveExpressionOptions();
using var expr = people.ActiveOrderBy(new ActiveOrderingKeySelector <TestPerson>(person => person.Name !.Length, options), new ActiveOrderingKeySelector <TestPerson>(person => person.Name !, options));
void checkMergedNames(string against) => Assert.AreEqual(against, string.Join(string.Empty, expr.Select(person => person.Name)));
checkMergedNames("BenErinJohnBryanCliffCraigEmilyJamesSteveGeorgeHunterBridgetCharlesNanette");
}
public void ValueDisposal()
{
var john = SyncDisposableTestPerson.CreateJohn();
var emily = SyncDisposableTestPerson.CreateEmily();
var people = new ObservableCollection <SyncDisposableTestPerson> {
john
};
var options = new ActiveExpressionOptions();
options.AddExpressionValueDisposal(() => new ObservableCollection <SyncDisposableTestPerson>()[0]);
using (var ae = ActiveExpression.Create(p => p[0], people, options))
{
Assert.AreSame(john, ae.Value);
Assert.IsFalse(john.IsDisposed);
people[0] = emily;
Assert.AreSame(emily, ae.Value);
Assert.IsTrue(john.IsDisposed);
}
Assert.IsTrue(emily.IsDisposed);
}
public void ValueAsyncDisposal()
{
var john = AsyncDisposableTestPerson.CreateJohn();
var options = new ActiveExpressionOptions();
options.AddConstructedTypeDisposal(typeof(AsyncDisposableTestPerson));
AsyncDisposableTestPerson first, second;
using (var expr = ActiveExpression.Create(() => new AsyncDisposableTestPerson(john.Name.Length.ToString()), options))
{
Assert.IsNull(expr.Fault);
first = expr.Value;
Assert.IsFalse(first.IsDisposed);
john.Name = string.Empty;
Assert.IsNull(expr.Fault);
second = expr.Value;
Assert.IsFalse(second.IsDisposed);
Assert.IsTrue(first.IsDisposed);
}
Assert.IsTrue(second.IsDisposed);
}
public void ValueDisposal()
{
var john = SyncDisposableTestPerson.CreateJohn();
var emily = SyncDisposableTestPerson.CreateEmily();
var options = new ActiveExpressionOptions();
options.AddExpressionValueDisposal(() => CombineSyncDisposablePeople(null !, null !));
SyncDisposableTestPerson?first, second;
using (var expr = ActiveExpression.Create(() => CombineSyncDisposablePeople(john.Name !.Length > 3 ? john : emily, emily), options))
{
Assert.IsNull(expr.Fault);
first = expr.Value;
Assert.IsFalse(first !.IsDisposed);
john.Name = string.Empty;
Assert.IsNull(expr.Fault);
second = expr.Value;
Assert.IsFalse(second !.IsDisposed);
Assert.IsTrue(first.IsDisposed);
}
Assert.IsTrue(second.IsDisposed);
}
public static EnumerableRangeActiveExpression <TElement, TResult> Create <TElement, TResult>(IEnumerable <TElement> source, Expression <Func <TElement, TResult> > expression, ActiveExpressionOptions options = null) => EnumerableRangeActiveExpression <TElement, TResult> .Create(source, expression, options);
public static ReadOnlyDictionaryRangeActiveExpression <TKey, TValue, TResult> Create <TKey, TValue, TResult>(IReadOnlyDictionary <TKey, TValue> source, Expression <Func <TKey, TValue, TResult> > expression, ActiveExpressionOptions options = null) => ReadOnlyDictionaryRangeActiveExpression <TKey, TValue, TResult> .Create(source, expression, options);
/// <summary>
/// Initializes a new instance of the <see cref="ActiveOrderingKeySelector{T}"/> class with the specified key extraction expression for sorting in the specified order
/// </summary>
/// <param name="expression">An expression to extract a key from an element</param>
/// <param name="expressionOptions">Options governing the behavior of active expressions created using <paramref name="expression"/></param>
/// <param name="isDescending"><c>true</c> to sort in descending order; otherwise, sort in ascending order</param>
public ActiveOrderingKeySelector(Expression <Func <T, IComparable> > expression, ActiveExpressionOptions expressionOptions, bool isDescending)
{
Expression = expression;
ExpressionOptions = expressionOptions;
IsDescending = isDescending;
}
/// <summary>
/// Initializes a new instance of the <see cref="ActiveOrderingKeySelector{T}"/> class with the specified key extraction expression for sorting in ascending order
/// </summary>
/// <param name="expression">An expression to extract a key from an element</param>
/// <param name="expressionOptions">Options governing the behavior of active expressions created using <paramref name="expression"/></param>
public ActiveOrderingKeySelector(Expression <Func <T, IComparable> > expression, ActiveExpressionOptions expressionOptions) : this(expression, expressionOptions, false)
{
}
