Использовать ftp в Blazor WebAssembly

 FtpWebRequest ftp = (FtpWebRequest)HttpWebRequest.Create(ftpfullpath);
            //ftp.Credentials = new NetworkCredential("login", "password");
            ftp.KeepAlive = false;
            ftp.UseBinary = true;
            ftp.UsePassive = false;
            ftp.Proxy = null;
            ftp.Method = WebRequestMethods.Ftp.MakeDirectory;
            FtpWebResponse resp = (FtpWebResponse)ftp.GetResponse();

IList<IBrowserFile> files = new List<IBrowserFile>();
    private async void UploadFiles(InputFileChangeEventArgs e)
    {
        foreach (var file in e.GetMultipleFiles())
        {
            files.Add(file);
            using (var ms = file.OpenReadStream(file.Size))
            {
                var result  = new StreamContent(ms, Convert.ToInt32(file.Size));
                var bytes  = await result.ReadAsByteArrayAsync();
                using var serverStream = GreeterClient.DownloadFileAsync(new FileRequest  { FileName = file.Name, FileBytes = Google.Protobuf.ByteString.CopyFrom(bytes)});
                var stream = await serverStream.ResponseAsync;
                var resultStatus = stream.Status;
            }
        }
    }

public override Task<StatusRequest> DownloadFile(FileRequest request, ServerCallContext context)
        {
            var fileBytes = request.FileBytes;
            var bytes = fileBytes.ToByteArray();
            string filename = @$"D:\123\{request.FileName}";
            File.WriteAllBytes(filename, bytes);
            return Task.FromResult(new StatusRequest
            {
                Status = filename + "|" + bytes.Count()
            });
        }

class Program
{
    static void Main(string[] args)
    {
        byte[] src_data = Encoding.UTF8.GetBytes($"public override Task<StatusRequest> ...");
        int length = 10;
        var to_send = SplitData(src_data, length); // разбить данные на части длиной length 
        var res_data = MergeData(to_send);         // объединить данные 
    } 
 
    private static byte[] MergeData(List<byte[]> data)
    {
        List<Package> packages = new List<Package>();
        foreach (var item in data)
        {
            string json = item.GZipDecompress();
            Package package = JsonConvert.DeserializeObject<Package>(json);
            packages.Add(package);
        }
        if (packages.Count > 0 && packages[0].t == packages.Count)
        {
 
            var src_bytes = packages
                .OrderBy(x => x.c)
                .Select(x => x.d)
                .ToArray();
            List<byte> result = new List<byte>();
            for (int i = 0; i < src_bytes.Length; i++)
            {
                result.AddRange(src_bytes[i]);
            }
            return result.ToArray();
        }
        return default;
    }
 
 
    private static List<byte[]> SplitData(byte[] src_data, int length)
    {
        int counter = length;
        var group_data = src_data.GroupBy(_ => counter++ / length)
            .Select(v => v.ToArray()).ToArray();
 
        List<byte[]> result = new List<byte[]>();
        for (int i = 0; i < group_data.Length; i++)
        {
            var package = new Package
            {
                c = i,
                d = group_data[i],
                t = group_data.Count()
            };
            byte[] data = JsonConvert.SerializeObject(package).GZipComptess();
            result.Add(data);
        }
        return result;
    }
}
 
class Package
{
    // CurrentNumber
    public int c { get; set; }
    // TotalCount
    public int t { get; set; }
    // Data
    public byte[] d { get; set; }
}
 
static class StringExtension
{
    public static byte[] GZipComptess(this string s)
    {
        var encoding = Encoding.UTF8;
        using (var outputStream = new MemoryStream())
        {
            using (var compressionStream = new GZipStream(outputStream, CompressionMode.Compress))
            using (var inputStream = new MemoryStream(encoding.GetBytes(s)))
                inputStream.CopyTo(compressionStream);
            return outputStream.ToArray();
        }
    }
 
    public static string GZipDecompress(this byte[] s)
    {
        var encoding = Encoding.UTF8;
        using (var outputStream = new MemoryStream())
        {
            using (var inputStream = new MemoryStream(s))
            using (var compressionStream = new GZipStream(inputStream, CompressionMode.Decompress))
                compressionStream.CopyTo(outputStream);
            return encoding.GetString(outputStream.ToArray());
        }
    }
}

using (var ms = item.OpenReadStream(item.Size))
             {
                var result  = new StreamContent(ms, Convert.ToInt32(item.Size));
                var bytes  = await result.ReadAsByteArrayAsync();
                var sblitDates = FileHelper.Сonverter.SplitData(bytes,10);
                ShowMessage(sblitDates.Count.ToString());
             }

services.AddGrpc(options =>
            {
                options.MaxReceiveMessageSize = 150 * 1024 * 1024; // 150 MB
                options.MaxSendMessageSize = 155 * 1024 * 1024; // 155 MB
            });

result.ReadAsByteArrayAsync()

public FileResult Download()
{
    byte[] fileBytes =  //...
    string fileName = "myfile.ext";
    return File(fileBytes, System.Net.Mime.MediaTypeNames.Application.Pdf, fileName);
}

return File(fileBytes, System.Net.Mime.MediaTypeNames.Application.Pdf, fileName);

using Microsoft.AspNetCore.Mvc;
 
namespace WebApplication1.Controllers
{
    public class HomeController : Controller
    {
        public FileResult Download()
        {
            byte[] fileBytes = System.IO.File.ReadAllBytes("file_path");
            //byte[] fileBytes = Encoding.UTF8.GetBytes("Text");
            string fileName = "file_name.ext";
            return File(fileBytes, System.Net.Mime.MediaTypeNames.Application.Pdf, fileName);
        }
    }
}

        var group_data = src_data.GroupBy(_ => counter++ / length)
            .Select(v => v.ToArray()).ToArray();

    var group_data = src_data.Split(length).ToArray();

//Класс расширение
public static class ArrSplit
{
    public static IEnumerable<byte[]> Split(this byte[] array, int size)
    {
        for (var i = 0; i < (float)array.Length / size; i++)
        {
            yield return array.Skip(i * size).Take(size).ToArray();
        }
    }
}

result.ReadAsByteArrayAsync()

using (var ms = file.OpenReadStream())
{
    using MemoryStream memoryStream = new MemoryStream();
    ms.CopyTo(memoryStream);
    var sblitDates = FileHelper.Сonverter.SplitData(memoryStream.ToArray(), 10);
    ShowMessage(sblitDates.Count.ToString());
}

 await ms.CopyToAsync(memoryStream);

await ms.CopyToAsync(memoryStream);