public async Task DownloadFileFromStreamAsync(Stream source, string fileName, string contentType)
{
var module = await moduleTask.Value;
using var streamRef = new DotNetStreamReference(source);
await module.InvokeVoidAsync("downloadFileFromStream", fileName, contentType, streamRef);
}
public async Task <DotNetStreamReference> TryClaimPendingStream(long streamId)
{
AssertInitialized();
AssertNotDisposed();
DotNetStreamReference dotNetStreamReference = null;
try
{
return(await Renderer.Dispatcher.InvokeAsync <DotNetStreamReference>(() =>
{
if (!JSRuntime.TryClaimPendingStreamForSending(streamId, out dotNetStreamReference))
{
throw new InvalidOperationException($"The stream with ID {streamId} is not available. It may have timed out.");
}
return dotNetStreamReference;
}));
}
catch (Exception ex)
{
// An error completing stream interop means that the user sent invalid data, a well-behaved
// client won't do this.
Log.SendDotNetStreamException(_logger, streamId, ex);
await TryNotifyClientErrorAsync(Client, GetClientErrorMessage(ex, "Unable to locate .NET stream."));
UnhandledException?.Invoke(this, new UnhandledExceptionEventArgs(ex, isTerminating: false));
return(default);
public void Write_WritesValidJson()
{
// Arrange
var streamRef = new DotNetStreamReference(new MemoryStream());
// Act
var json = JsonSerializer.Serialize(streamRef, JsonSerializerOptions);
// Assert
Assert.Equal("{\"__dotNetStream\":1}", json);
}
public void Write_WritesMultipleValidJson()
{
// Arrange
var streamRef = new DotNetStreamReference(new MemoryStream());
// Act & Assert
for (var i = 1; i <= 10; i++)
{
var json = JsonSerializer.Serialize(streamRef, JsonSerializerOptions);
Assert.Equal($"{{\"__dotNetStream\":{i}}}", json);
}
}
public void BeginTransmittingStream_MultipleStreams()
{
// Arrange
var runtime = new TestJSRuntime();
var streamRef = new DotNetStreamReference(new MemoryStream());
// Act & Assert
for (var i = 1; i <= 10; i++)
{
Assert.Equal(i, runtime.BeginTransmittingStream(streamRef));
}
}
public static DotNetStreamReference GetDotNetStreamReference()
{
var data = new byte[100000];
for (var i = 0; i < data.Length; i++)
{
data[i] = (byte)(i % 256);
}
var dataStream = new MemoryStream(data);
var streamRef = new DotNetStreamReference(dataStream);
return(streamRef);
}
public async Task <int> SendDotNetStreamAsync(DotNetStreamReference dotNetStreamReference, long streamId, byte[] buffer)
{
AssertInitialized();
AssertNotDisposed();
try
{
return(await Renderer.Dispatcher.InvokeAsync <int>(async() => await dotNetStreamReference.Stream.ReadAsync(buffer)));
}
catch (Exception ex)
{
// An error completing stream interop means that the user sent invalid data, a well-behaved
// client won't do this.
Log.SendDotNetStreamException(_logger, streamId, ex);
await TryNotifyClientErrorAsync(Client, GetClientErrorMessage(ex, "Unable to send .NET stream."));
UnhandledException?.Invoke(this, new UnhandledExceptionEventArgs(ex, isTerminating: false));
return(0);
}
}
internal static async Task TransmitStreamAsync(IJSRuntime runtime, long streamId, DotNetStreamReference dotNetStreamReference)
{
var buffer = ArrayPool <byte> .Shared.Rent(32 * 1024);
try
{
int bytesRead;
while ((bytesRead = await dotNetStreamReference.Stream.ReadAsync(buffer)) > 0)
{
await runtime.InvokeVoidAsync("Blazor._internal.receiveDotNetDataStream", streamId, buffer, bytesRead, null);
}
// Notify client that the stream has completed
await runtime.InvokeVoidAsync("Blazor._internal.receiveDotNetDataStream", streamId, Array.Empty <byte>(), 0, null);
}
catch (Exception ex)
{
try
{
// Attempt to notify the client of the error.
await runtime.InvokeVoidAsync("Blazor._internal.receiveDotNetDataStream", streamId, Array.Empty <byte>(), 0, ex.Message);
}
catch
{
// JS Interop encountered an issue, unable to send error message to JS.
}
throw;
}
finally
{
ArrayPool <byte> .Shared.Return(buffer, clearArray : true);
if (!dotNetStreamReference.LeaveOpen)
{
dotNetStreamReference.Stream?.Dispose();
}
}
}
