public async Task Timeout() { { var delay = Task.Delay(TimeSpan.FromMilliseconds(100)); var vtask = CreateAsync(999); var(hasValue, value) = await ValueTaskEx.WhenAny(vtask, delay); hasValue.Should().BeTrue(); value.Should().Be(999); } { var delay = Task.Delay(TimeSpan.FromMilliseconds(100)); var vtask = CreateAsyncSlow(999); var(hasValue, value) = await ValueTaskEx.WhenAny(vtask, delay); hasValue.Should().BeFalse(); } { var delay = Task.Delay(TimeSpan.FromMilliseconds(100)); var vtask = CreateSync(999); var(hasValue, value) = await ValueTaskEx.WhenAny(vtask, delay); hasValue.Should().BeTrue(); value.Should().Be(999); } }
protected override ValueTask <string?> Load(string key, CancellationToken cancellationToken) { if (!Storage.TryGetValue(key, out var value)) { return(ValueTaskEx.FromResult((string?)null)); } ExpirationTimers.AddOrUpdateToLater(key, Clock.Now + ExpirationTime); return(ValueTaskEx.FromResult(value) !); }
public async Task AnySync() { var a = CreateSync(); var b = CreateSync(); var c = CreateSync(); var result = await ValueTaskEx.WhenAny(a, b, c); result.Should().Be(0); }
public async Task WithAsync() { var a = CreateSync(1); var b = CreateAsync(2); var c = CreateAsync(3); var result = await ValueTaskEx.WhenAll(a, b, c); result.Should().Be((1, 2, 3)); }
public async Task Array() { var a = CreateSync(1); var b = CreateAsync(2); var c = CreateAsync(3); var result = await ValueTaskEx.WhenAll(new[] { a, b, c }); result.Should().BeEquivalentTo(new[] { 1, 2, 3 }); }
public async Task Array() { var a = CreateSync(); var b = CreateAsync(); var c = CreateAsyncSlow(); var result = await ValueTaskEx.WhenAny(new[] { a, b, c }); result.Should().Be(0); }
public async Task WithAsync() { var a = CreateAsync(); var b = CreateSync(); var c = CreateAsyncSlow(); var result = await ValueTaskEx.WhenAny(a, b, c); result.Should().Be(1); }
protected override ValueTask <Option <string> > Load(string key, CancellationToken cancellationToken) { if (!Storage.TryGetValue(key, out var value)) { return(ValueTaskEx.FromResult(Option.None <string>())); } ExpirationTimers.AddOrUpdateToLater(key, Clock.Now + ExpirationTime); return(ValueTaskEx.FromResult(Option.Some(value))); }
public async Task WithNewContextResult() { AsyncContext.Ensure(); var id = AsyncContext.CurrentContext.Id; var idx = await ValueTaskEx.WithNewContext(() => new ValueTask <long>(AsyncContext.CurrentContext.Id)); Assert.That(idx, Is.Not.EqualTo(id)); }
public async Task WithNewContextResultToken() { AsyncContext.Ensure(); var id = AsyncContext.CurrentContext.Id; var idx = await ValueTaskEx.WithNewContext(token => new ValueTask <long>(AsyncContext.CurrentContext.Id), CancellationToken.None); Assert.That(idx, Is.Not.EqualTo(id)); }
public async Task Array() { var a = CreateSync(1); var b = CreateAsync(2); var c = CreateAsync(3); var result = await ValueTaskEx.WhenAny(new[] { a, b, c }); result.winArgumentIndex.Should().Be(0); result.result.Should().Be(1); }
static async Task Main(string[] args) { var ta = Foo(); var tb = new ValueTask <int>(100); var tc = Foo(); var tako = ValueTaskEx.WhenAll(ta, tb, tc); var(a, b, c) = await tako; }
public async Task WithAsync() { var a = CreateAsync(1); var b = CreateSync(2); var c = CreateAsync(3); var result = await ValueTaskEx.WhenAny(a, b, c); result.winArgumentIndex.Should().Be(1); result.result1.Should().Be(2); }
public async Task Async() { var calledCount = 0; var syncLazy = ValueTaskEx.Lazy(async() => { calledCount++; await Task.Delay(TimeSpan.FromSeconds(1)); }); calledCount.Should().Be(0); await ValueTaskEx.WhenAll(syncLazy, syncLazy, syncLazy); calledCount.Should().Be(1); }
public async Task WithNewContextToken() { AsyncContext.Ensure(); var id = AsyncContext.CurrentContext.Id; long idx = -1; await ValueTaskEx.WithNewContext(token => { idx = AsyncContext.CurrentContext.Id; return(new ValueTask()); }, CancellationToken.None); Assert.That(idx, Is.Not.EqualTo(id)); }
public override ValueTask SendAsync(ReadOnlyMemory <byte> dataBuffer) { List <ValueTask> sendTasks = new List <ValueTask>(); lock (this.connectedSockets) { foreach (var clientSocket in this.connectedSockets) { sendTasks.Add(clientSocket.SendAsync(dataBuffer)); } } return(ValueTaskEx.WhenAll(sendTasks)); }
public async Task WithNewContext() { AsyncContext.Ensure(); var id = AsyncContext.CurrentContext.Id; long idx = -1; await ValueTaskEx.WithNewContext(() => { idx = AsyncContext.CurrentContext.Id; return(new ValueTask()); }); Assert.That(idx, Is.Not.EqualTo(id)); }
public async Task Async() { var calledCount = 0; var syncLazy = ValueTaskEx.Lazy(async() => { calledCount++; await Task.Delay(TimeSpan.FromSeconds(1)); return(new object()); }); calledCount.Should().Be(0); var(v1, v2, v3) = await ValueTaskEx.WhenAll(syncLazy, syncLazy, syncLazy); calledCount.Should().Be(1); object.ReferenceEquals(v1, v2).Should().BeTrue(); object.ReferenceEquals(v2, v3).Should().BeTrue(); }
public async Task Sync() { var calledCount = 0; var syncLazy = ValueTaskEx.Lazy(async() => { calledCount++; }); calledCount.Should().Be(0); await syncLazy; calledCount.Should().Be(1); await syncLazy; calledCount.Should().Be(1); }
public async Task AllSync() { var a = CreateSync(); var b = CreateSync(); var c = CreateSync(); a.IsCompletedSuccessfully.Should().BeTrue(); b.IsCompletedSuccessfully.Should().BeTrue(); c.IsCompletedSuccessfully.Should().BeTrue(); await ValueTaskEx.WhenAll(a, b, c); a.IsCompletedSuccessfully.Should().BeTrue(); b.IsCompletedSuccessfully.Should().BeTrue(); c.IsCompletedSuccessfully.Should().BeTrue(); }
public async Task Array() { var a = CreateSync(); var b = CreateAsync(); var c = CreateAsync(); a.IsCompletedSuccessfully.Should().BeTrue(); b.IsCompletedSuccessfully.Should().BeFalse(); c.IsCompletedSuccessfully.Should().BeFalse(); await ValueTaskEx.WhenAll(new[] { a, b, c }); a.IsCompletedSuccessfully.Should().BeTrue(); b.IsCompletedSuccessfully.Should().BeTrue(); c.IsCompletedSuccessfully.Should().BeTrue(); }
/// <inheritdoc/> public ValueTask <IFileSystemEntry> GetFileAsync(string name, CancellationToken cancellationToken = default) { if (cancellationToken.IsCancellationRequested) { return(ValueTaskEx.FromCanceled <IFileSystemEntry>(cancellationToken)); } IFileInfo file = this.fileProvider.GetFileInfo(ToFilePath(name)); if (!file.Exists) { return(ValueTaskEx.FromResult <IFileSystemEntry>(null)); } return(ValueTaskEx.FromResult <IFileSystemEntry>(new PhysicalFileSystemEntry(file, this.contentTypeProvider))); }
public async ValueTask <string?> FormatAsync(string text, EnrichedEvent @event) { if (string.IsNullOrWhiteSpace(text)) { return(text); } if (TryGetTemplate(text.Trim(), out var template)) { var vars = new TemplateVars { ["event"] = @event }; return(await templateEngine.RenderAsync(template, vars)); } if (TryGetScript(text.Trim(), out var script)) { // Script vars are just wrappers over dictionaries for better performance. var vars = new EventScriptVars { Event = @event, AppId = @event.AppId.Id, AppName = @event.AppId.Name, User = Admin() }; var result = (await scriptEngine.ExecuteAsync(vars, script)).ToString(); if (result == "undefined") { return(GlobalFallback); } return(result); } var parts = BuildParts(text, @event); if (parts.Any(x => !x.Var.IsCompleted)) { await ValueTaskEx.WhenAll(parts.Select(x => x.Var)); } return(CombineParts(text, parts)); }
// Protected methods protected static void SetReturnValue(InterceptedInput input, Result <TOut> output) { if (input.Method.ReturnsValueTask) { input.Invocation.ReturnValue = output.IsValue(out var v) ? ValueTaskEx.FromResult(v) : ValueTaskEx.FromException <TOut>(output.Error !); } else { input.Invocation.ReturnValue = output.IsValue(out var v) ? Task.FromResult(v) : Task.FromException <TOut>(output.Error !); } }
/// <inheritdoc/> public ValueTask <bool> TryDeleteFileAsync(string name, CancellationToken cancellationToken = default) { if (cancellationToken.IsCancellationRequested) { return(ValueTaskEx.FromCanceled <bool>(cancellationToken)); } IFileInfo file = this.fileProvider.GetFileInfo(ToFilePath(name)); if (!file.Exists) { return(ValueTaskEx.FromResult(false)); } File.Delete(file.PhysicalPath); return(ValueTaskEx.FromResult(true)); }
public async ValueTask <string?> FormatAsync(string text, EnrichedEvent @event) { if (string.IsNullOrWhiteSpace(text)) { return(text); } if (TryGetTemplate(text.Trim(), out var template)) { var vars = new TemplateVars { ["event"] = @event }; return(await templateEngine.RenderAsync(template, vars)); } if (TryGetScript(text.Trim(), out var script)) { var vars = new ScriptVars { ["event"] = @event }; #pragma warning disable MA0042 // Do not use blocking calls in an async method var result = scriptEngine.Execute(vars, script).ToString(); #pragma warning restore MA0042 // Do not use blocking calls in an async method if (result == "undefined") { return(GlobalFallback); } return(result); } var parts = BuildParts(text, @event); if (parts.Any(x => !x.Var.IsCompleted)) { await ValueTaskEx.WhenAll(parts.Select(x => x.Var)); } return(CombineParts(text, parts)); }
/// <summary> /// 検索データを構築します。 /// </summary> /// <param name="shortCode"></param> /// <param name="cancellationToken"></param> /// <returns></returns> public async ValueTask <SearchMetadata> BuildAsync(string shortCode, CancellationToken cancellationToken = default) { var post = await this.ScrapingService.ExtractPostAsync(shortCode, cancellationToken).ConfigureAwait(false); if (post.Owner.UserName != AccountName) { var message = $"{AccountName} 以外の投稿データを取得しようとしています | AccountName : {post.Owner.UserName}"; throw new InvalidOperationException(message); } var result = CaptionParser.Parse(post.Caption); var metadata = new SearchMetadata(post, result); var t1 = this.CopyThumbnailAsync(post.Medias[0].ImageUrl, metadata.Number, overwrite: true, cancellationToken); var t2 = this.UploadMetadataAsync(metadata, cancellationToken); await ValueTaskEx.WhenAll(t1, t2).ConfigureAwait(false); return(metadata); }
// Protected methods protected static void SetReturnValue(ComputeMethodInput input, Result <TOut> output) { if (input.Method.ReturnsValueTask) { input.Invocation.ReturnValue = // ReSharper disable once HeapView.BoxingAllocation output.IsValue(out var v) ? ValueTaskEx.FromResult(v) : ValueTaskEx.FromException <TOut>(output.Error !); } else { input.Invocation.ReturnValue = output.IsValue(out var v) ? Task.FromResult(v) : Task.FromException <TOut>(output.Error !); } }
public async Task Sync() { var calledCount = 0; var syncLazy = ValueTaskEx.Lazy(async() => { calledCount++; return(100); }); calledCount.Should().Be(0); var value = await syncLazy; value.Should().Be(100); calledCount.Should().Be(1); var value2 = await syncLazy; value.Should().Be(100); calledCount.Should().Be(1); }
/// <inheritdoc/> public async ValueTask PutFileAsync(IFileSystemEntry entry, CancellationToken cancellationToken = default) { if (cancellationToken.IsCancellationRequested) { await ValueTaskEx.FromCanceled(cancellationToken); } string name = entry.Name; string path = Path.Combine(this.root, ToFilePath(name)); string directory = Path.GetDirectoryName(path); if (!Directory.Exists(directory)) { Directory.CreateDirectory(directory); } using Stream stream = await entry.CreateReadStreamAsync(); using FileStream fileStream = File.Create(path); await stream.CopyToAsync(fileStream, cancellationToken); }