public static async UniTask UpdateWhile(Func <AsyncUnit, bool> whilePredicate, Action action, CancellationToken token = default)
{
await UniTaskAsyncEnumerable.EveryUpdate().TakeWhile(whilePredicate).ForEachAsync(_ =>
{
action?.Invoke();
}, token);
}
public async Task Sum(int start, int count)
{
{
var xs = await UniTaskAsyncEnumerable.Range(start, count).SumAsync();
var ys = Enumerable.Range(start, count).Sum();
xs.Should().Be(ys);
}
{
var xs = await UniTaskAsyncEnumerable.Range(start, count).SumAsync(x => x * 2);
var ys = Enumerable.Range(start, count).Sum(x => x * 2);
xs.Should().Be(ys);
}
{
var xs = await UniTaskAsyncEnumerable.Range(start, count).SumAwaitAsync(x => UniTask.Run(() => x));
var ys = Enumerable.Range(start, count).Sum(x => x);
xs.Should().Be(ys);
}
{
var xs = await UniTaskAsyncEnumerable.Range(start, count).SumAwaitWithCancellationAsync((x, _) => UniTask.Run(() => x));
var ys = Enumerable.Range(start, count).Sum(x => x);
xs.Should().Be(ys);
}
}
static async UniTask Main()
{
await foreach (var _ in UniTaskAsyncEnumerable.EveryUpdate())
{
Console.WriteLine("Update");
}
}
public static async UniTask UpdateForSeconds(float sec, Action action, CancellationToken token = default)
{
await UniTaskAsyncEnumerable.EveryUpdate().TakeUntil(UniTask.Delay(TimeSpan.FromSeconds(sec))).ForEachAsync(_ =>
{
action?.Invoke();
}, token);
}
public async Task Count(int start, int count)
{
{
var xs = await UniTaskAsyncEnumerable.Range(start, count).CountAsync();
var ys = Enumerable.Range(start, count).Count();
xs.Should().Be(ys);
}
{
var xs = await UniTaskAsyncEnumerable.Range(start, count).CountAsync(x => x % 2 == 0);
var ys = Enumerable.Range(start, count).Count(x => x % 2 == 0);
xs.Should().Be(ys);
}
{
var xs = await UniTaskAsyncEnumerable.Range(start, count).LongCountAsync();
var ys = Enumerable.Range(start, count).LongCount();
xs.Should().Be(ys);
}
{
var xs = await UniTaskAsyncEnumerable.Range(start, count).LongCountAsync(x => x % 2 == 0);
var ys = Enumerable.Range(start, count).LongCount(x => x % 2 == 0);
xs.Should().Be(ys);
}
}
static async Task Main(string[] args)
{
#if !DEBUG
//await new AllocationCheck().ViaUniTaskVoid();
//Console.ReadLine();
BenchmarkDotNet.Running.BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
//await new ComparisonBenchmarks().ViaUniTaskT();
return;
#endif
var e = UniTaskAsyncEnumerable.Create <int>(async(writer, token) =>
{
for (int i = 0; i < 5; i++)
{
Console.WriteLine($"Start {i}");
await writer.YieldAsync(i);
Console.WriteLine($"End {i}");
}
});
var ee = e.GetAsyncEnumerator();
while (await ee.MoveNextAsync())
{
Console.WriteLine("ForEach " + ee.Current);
}
}
public IEnumerator TimerFrameSinglePre() => UniTask.ToCoroutine(async() =>
{
{
await UniTask.Yield(PlayerLoopTiming.PreUpdate);
var initialFrame = Time.frameCount;
var xs = await UniTaskAsyncEnumerable.TimerFrame(0).Select(_ => Time.frameCount).ToArrayAsync();
xs[0].Should().Be(initialFrame);
}
{
await UniTask.Yield(PlayerLoopTiming.PreUpdate);
var initialFrame = Time.frameCount;
var xs = await UniTaskAsyncEnumerable.TimerFrame(1).Select(_ =>
{
var t = Time.frameCount;
return(t);
}).ToArrayAsync();
xs[0].Should().Be(initialFrame + 1);
}
{
await UniTask.Yield(PlayerLoopTiming.PreUpdate);
var initialFrame = Time.frameCount;
var xs = await UniTaskAsyncEnumerable.TimerFrame(2).Select(_ => Time.frameCount).ToArrayAsync();
xs[0].Should().Be(initialFrame + 2);
}
});
public async Task ReturnTest <T>(T value)
{
var xs = await UniTaskAsyncEnumerable.Return(value).ToArrayAsync();
xs.Length.Should().Be(1);
xs[0].Should().Be(value);
}
public async Task RepeatTest(string value, int count)
{
var xs = await UniTaskAsyncEnumerable.Repeat(value, count).ToArrayAsync();
var ys = Enumerable.Repeat(value, count).ToArray();
xs.Should().Equal(ys);
}
public async Task BufferSkip(int rangeCount, int bufferCount, int skipCount)
{
var xs = await UniTaskAsyncEnumerable.Range(0, rangeCount).Buffer(bufferCount, skipCount).Select(x => string.Join(",", x)).ToArrayAsync();
var ys = await AsyncEnumerable.Range(0, rangeCount).Buffer(bufferCount, skipCount).Select(x => string.Join(",", x)).ToArrayAsync();
xs.Should().Equal(ys);
}
public PlayerStreams(PlayerState playerState)
{
this.playerState = playerState;
countStream = UniTaskAsyncEnumerable
.EveryValueChanged(playerState, s => s.players.Count)
.Select(_ => playerState.players.Select(x => x.id))
.ToReadOnlyAsyncReactiveProperty(cts.Token);
}
private async UniTaskVoid Start()
{
await UniTaskAsyncEnumerable
.Range(0, 5)
.ForEachAsync(x => Debug.Log(x));
Debug.Log("Done");
}
private async UniTaskVoid Start()
{
await UniTaskAsyncEnumerable
.Empty <int>()
.ForEachAsync(x => Debug.Log(x));
Debug.Log("Done");
}
private async UniTaskVoid Start()
{
await UniTaskAsyncEnumerable
.Repeat("Hi!", 3)
.ForEachAsync(x => Debug.Log(x));
Debug.Log("Done");
}
public async Task RangeTest(int start, int count)
{
var xs = await UniTaskAsyncEnumerable.Range(start, count).ToArrayAsync();
var ys = Enumerable.Range(start, count).ToArray();
xs.Should().Equal(ys);
}
public async Task TakeLast(int collection, int takeCount)
{
var xs = await UniTaskAsyncEnumerable.Range(1, collection).TakeLast(takeCount).ToArrayAsync();
var ys = Enumerable.Range(1, collection).TakeLast(takeCount).ToArray();
xs.Should().Equal(ys);
}
public async Task EmptyTest()
{
var xs = await UniTaskAsyncEnumerable.Empty <int>().ToArrayAsync();
var ys = Enumerable.Empty <int>().ToArray();
xs.Should().Equal(ys);
}
public async Task Skip(int collection, int skipCount)
{
var xs = await UniTaskAsyncEnumerable.Range(1, collection).Skip(skipCount).ToArrayAsync();
var ys = Enumerable.Range(1, collection).Skip(skipCount).ToArray();
xs.Should().Equal(ys);
}
private void Start()
{
this.Magenta($"[{GetType().Name}] Press {_triggerKey} to start fade-in and fade-out.");
var token = this.GetCancellationTokenOnDestroy();
UniTaskAsyncEnumerable.EveryValueChanged(this, fade => Input.GetKeyDown(_triggerKey))
.SubscribeAwait(async _ => await DummyLoadingProgress(token), token);
}
private async UniTaskVoid Start()
{
await UniTaskAsyncEnumerable
.EveryUpdate()
.ForEachAsync(_ =>
{
// Every update.
Debug.Log(Time.frameCount);
}, this.GetCancellationTokenOnDestroy());
}
public IEnumerator TimerFrameSinglePre2() => UniTask.ToCoroutine(async() =>
{
{
var xs = await UniTaskAsyncEnumerable.TimerFrame(1).ToArrayAsync();
}
Debug.Log("------------------");
{
var xs = await UniTaskAsyncEnumerable.TimerFrame(1).ToArrayAsync();
}
});
private void Start()
{
var token = this.GetCancellationTokenOnDestroy();
_cubeIndex.WithoutCurrent().Subscribe(OpenBottom, token);
UniTaskAsyncEnumerable.EveryValueChanged(_activeCube, collection => collection.IsCompleted)
.Where(completed => completed)
.Subscribe(_ => OnCubeCompleted(), token);
}
/// <summary>
/// 按下之后开启一个定时器，定期触发，当松开之后删除这个定时器
/// </summary>
/// <param name="action"></param>
void RegisterHoldPress(Action action)
{
btn.GetAsyncPointerDownTrigger()
.Subscribe(
async _ => {
UniTaskAsyncEnumerable.Timer(TimeSpan.FromMilliseconds(3000), TimeSpan.FromMilliseconds(250))
.TakeUntil(btn.GetAsyncPointerUpTrigger().FirstAsync()).Subscribe(o => { action.Invoke(); })
.AddTo(this.GetCancellationTokenOnDestroy());
}
);
}
private void Start()
{
var targetToken = _target.GetCancellationTokenOnDestroy();
UniTaskAsyncEnumerable.EveryUpdate()
// 対象がキャンセル状態になったら値が取得できるようになる
.SkipUntilCanceled(targetToken)
.ForEachAsync(
_ => Debug.Log(Time.frameCount),
this.GetCancellationTokenOnDestroy());
}
private async UniTaskVoid Start()
{
await UniTaskAsyncEnumerable
.Never <int>()
.ForEachAsync(
x => Debug.Log(x),
this.GetCancellationTokenOnDestroy());
// ここには決して到達しない
Debug.Log("Done");
}
/// <summary>
/// 在C#7.0中创建自己的UniTaskAsyncEnumerable,
/// C#8.0有更加简洁的语法支持，但在使用Unity2020之前不考虑它。
///
/// 除非真的很通用，你可能没有必要实现自己的UniTaskAsyncEnumerable
/// 通常特殊条件才yield产出的Enumerable都可以通过现有的AsyncEnumerable过滤来获得。
/// </summary>
/// <returns></returns>
public IUniTaskAsyncEnumerable <int> MyEveryUpdate()
{
return(UniTaskAsyncEnumerable.Create <int>(async(writer, token) => {
var frameCount = 0;
await UniTask.Yield();
while (!token.IsCancellationRequested)
{
await writer.YieldAsync(frameCount++);
await UniTask.Yield();
}
}));
}
private void Start()
{
var token = this.GetCancellationTokenOnDestroy();
_screenCamera.Subscribe(_ => ForceCalculateResolution()).AddTo(token);
#if UNITY_EDITOR
UniTaskAsyncEnumerable.EveryUpdate().Subscribe(unit => CalculateResolution()).AddTo(token);
#endif
CalculateResolution();
}
private void Start()
{
// Publish()の返り値は
// IConnectableUniTaskAsyncEnumerable<T>
_connectableUniTaskAsyncEnumerable =
UniTaskAsyncEnumerable
.EveryUpdate().Publish();
// この時点ではまだ値は発行されない
_connectableUniTaskAsyncEnumerable
.ForEachAsync(_ => Debug.Log(Time.frameCount));
}
// 指定の整数がゼロになるまで一定間隔でカウントダウンする
private IUniTaskAsyncEnumerable <int> CountDownAsync(int startCount, TimeSpan timeSpan)
{
return(UniTaskAsyncEnumerable.Create <int>(async(writer, token) =>
{
var currentCount = startCount;
while (currentCount >= 0)
{
// writer.YieldAsync を使うと UniTaskAsyncEnumerable に値が書き込まれる
await writer.YieldAsync(currentCount--);
await UniTask.Delay(timeSpan, cancellationToken: token);
}
}));
}
private async UniTaskVoid ExecuteAsync()
{
Debug.Log("1");
{
var xs = await UniTaskAsyncEnumerable.TimerFrame(1).ToArrayAsync();
}
Debug.Log("------------------");
{
var xs = await UniTaskAsyncEnumerable.TimerFrame(1).ToArrayAsync();
Debug.Log("2");
}
}
