public async Task <IEnumerable <MetadataReference> > AddPackage(string packageName, string packageVersion)
{
var package = await _lazyPackage.ValueAsync();
var currentWorkspace = await package.CreateRoslynWorkspaceForRunAsync(new Budget());
var currentRefs = new HashSet <string>(
currentWorkspace.CurrentSolution.Projects.First().MetadataReferences
.Select(m => m.Display));
var dotnet = new Dotnet(package.Directory);
var result = await dotnet.AddPackage(packageName, packageVersion);
if (result.ExitCode != 0)
{
return(Array.Empty <MetadataReference>());
}
var newWorkspace = await package.CreateRoslynWorkspaceForRunAsync(new Budget());
var newRefs = new HashSet <MetadataReference>(newWorkspace.CurrentSolution.Projects.First().MetadataReferences);
var resultRefs = newRefs.Where(n => !currentRefs.Contains(n.Display));
return(resultRefs);
}
public async Task AsyncLazy_can_be_awaited_concurrently_without_triggering_initialization_twice()
{
var callCount = 0;
var barrier = new Barrier(5);
var lazy = new AsyncLazy <string>(async() =>
{
await Task.Yield();
barrier.SignalAndWait(2000);
Interlocked.Increment(ref callCount);
barrier.SignalAndWait(2000);
return("hello!");
});
var calls = Enumerable.Range(1, 5)
.Select(_ => lazy.ValueAsync());
await Task.WhenAll(calls);
callCount.Should().Be(1);
}
public async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request)
{
var httpClient = await _getHttpClient.ValueAsync();
var response = await httpClient.SendAsync(request);
return(response);
}
protected override void DisposeManagedResources()
{
if (_encryptedCollection != null)
{
Array.Clear(_encryptedCollection, 0, _encryptedCollection.Length);
}
if (_encryptionKey != null)
{
TaskContext.RunSync(() => _encryptionKey.ValueAsync()).Dispose(); //TODO: Use IAsyncDisposable instead in C# 8.0
}
Length = 0;
}
public static async Task <IDecryptedBytesMarshaler> RevealDecryptedBytesAsync(
this AsyncLazy <IMemoryProtectedBytes> lazyBytes)
{
if (lazyBytes == null)
{
throw new ArgumentNullException(nameof(lazyBytes));
}
var bytes = await lazyBytes.ValueAsync().ConfigureAwait(false);
var marshaler = await bytes.RevealDecryptedBytesAsync().ConfigureAwait(false);
return(marshaler);
}
public async Task AsyncLazy_returns_the_specified_value()
{
var lazy = new AsyncLazy <string>(async() =>
{
await Task.Yield();
return("hello!");
});
var value = await lazy.ValueAsync();
value.Should().Be("hello!");
}
protected Task <bool> EnsureCreated() => _lazyCreation.ValueAsync();
public static Task <Package> NetstandardWorkspace() => _lazyBlazorConsole.ValueAsync();
public static Task <Package> XunitWorkspace() => _lazyXunit.ValueAsync();
public static Task <Package> WebApiWorkspace() => _lazyAspnetWebapi.ValueAsync();
public static Task <Package> ConsoleWorkspace() => _lazyConsole.ValueAsync();
public async Task <HttpResponseMessage> GetAsync(string requestUri)
{
await _lazyReady.ValueAsync();
return(await _client.GetAsync(requestUri));
}
public Task <Uri> EnsureStarted() => _listeningAtUri.ValueAsync();
public async Task <string> OutputPath() => (await _lazyPackage.ValueAsync()).EntryPointAssemblyPath.FullName;
