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);
}
