无法通过asp.net核心服务器端将~200mb的文件上载到azure blob存储

我在Asp.net核心上有一个服务器部件，它接收一个内容类型为：multipart/form data format header的文件，并以流的形式将其发送到azure blob存储。但当我发送大约200 MB或更多的文件时，我有一个错误

“请求正文太大，超出了允许的最大限制”

当我搜索时，它可能发生在旧版本的WindowsAzure.Storage中，但我有版本9.1.1。当我查看更深入的方法UploadFromStreamAsync时，默认情况下，chank blob为4MB。所以我不知道该怎么办，只想请你帮忙。 我的控制器：

public async Task<IActionResult> Post(string folder)
    {
        string azureBlobConnectionString = _configuration.GetConnectionString("BlobConnection");
        // Retrieve storage account from connection string.
        CloudStorageAccount storageAccount = CloudStorageAccount.Parse(azureBlobConnectionString);

        HttpResponseUploadClass responseUploadClass = await Request.StreamFile(folder, storageAccount);
        FormValueProvider formModel = responseUploadClass.FormValueProvider;

        var viewModel = new MyViewModel();

        var bindingSuccessful = await TryUpdateModelAsync(viewModel, prefix: "",
            valueProvider: formModel);

        if (!bindingSuccessful)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
        }

        return Ok(responseUploadClass.Url);
    }

公共异步任务Post（字符串文件夹）
{
string azureBlobConnectionString=_配置.GetConnectionString（“BlobConnection”）；
//从连接字符串中检索存储帐户。
CloudStorageAccount-storageAccount=CloudStorageAccount.Parse（azureBlobConnectionString）；
HttpResponseUploadClass responseUploadClass=等待请求.StreamFile（文件夹，存储帐户）；
FormValueProvider formModel=responseUploadClass.FormValueProvider；
var viewModel=新的MyViewModel（）；
var bindingSuccessful=await TryUpdateModelAsync（viewModel，前缀：“”，
valueProvider:formModel）；
如果（！bindingSuccessful）
{
如果（！ModelState.IsValid）
{
返回请求（ModelState）；
}
}
返回Ok（responseUploadClass.Url）；
}

和类，我在其中向azure blob发送流文件流

 public static async Task<HttpResponseUploadClass> StreamFile(this HttpRequest request, string folder, CloudStorageAccount blobAccount)
    {
        CloudBlobClient blobClient = blobAccount.CreateCloudBlobClient();
        CloudBlobContainer container = blobClient.GetContainerReference(folder);
        CloudBlockBlob blockBlob = null;

        if (!MultipartRequestHelper.IsMultipartContentType(request.ContentType))
        {
            throw new Exception($"Expected a multipart request, but got {request.ContentType}");
        }
        var formAccumulator = new KeyValueAccumulator();

        var boundary = MultipartRequestHelper.GetBoundary(
            MediaTypeHeaderValue.Parse(request.ContentType),
            DefaultFormOptions.MultipartBoundaryLengthLimit);
        var reader = new MultipartReader(boundary, request.Body);

        var section = await reader.ReadNextSectionAsync();
        while (section != null)
        {
            ContentDispositionHeaderValue contentDisposition;
            var hasContentDispositionHeader = ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out contentDisposition);
            var disposition = ContentDispositionHeaderValue.Parse(section.ContentDisposition);
            if (hasContentDispositionHeader)
            {
                if (MultipartRequestHelper.HasFileContentDisposition(contentDisposition))
                {
                    try
                    {
                        string fileName = HttpUtility.UrlEncode(disposition.FileName.Value.Replace("\"", ""), Encoding.UTF8);
                        blockBlob = container.GetBlockBlobReference(Guid.NewGuid().ToString());
                        blockBlob.Properties.ContentType = GetMimeTypeByWindowsRegistry(fileName);
                        blockBlob.Properties.ContentDisposition = "attachment; filename*=UTF-8''" + fileName;
                        await blockBlob.UploadFromStreamAsync(section.Body);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e);
                        throw;
                    }
                }
                else if (MultipartRequestHelper.HasFormDataContentDisposition(contentDisposition))
                {
                    var key = HeaderUtilities.RemoveQuotes(contentDisposition.Name);
                    var encoding = GetEncoding(section);
                    using (var streamReader = new StreamReader(
                        section.Body,
                        encoding,
                        detectEncodingFromByteOrderMarks: true,
                        bufferSize: 1024,
                        leaveOpen: true))
                    {
                        var value = await streamReader.ReadToEndAsync();
                        if (String.Equals(value, "undefined", StringComparison.OrdinalIgnoreCase))
                        {
                            value = String.Empty;
                        }
                        formAccumulator.Append(key.Value, value);

                        if (formAccumulator.ValueCount > DefaultFormOptions.ValueCountLimit)
                        {
                            throw new InvalidDataException($"Form key count limit {DefaultFormOptions.ValueCountLimit} exceeded.");
                        }
                    }
                }
            }
            section = await reader.ReadNextSectionAsync();
        }
        var formValueProvider = new FormValueProvider(
            BindingSource.Form,
            new FormCollection(formAccumulator.GetResults()),
            CultureInfo.CurrentCulture);

        return new HttpResponseUploadClass{FormValueProvider = formValueProvider, Url = blockBlob?.Uri.ToString()};
    }

公共静态异步任务流文件（此HttpRequest请求、字符串文件夹、CloudStorageAccount blobAccount）
{
CloudBlobClient blobClient=blobAccount.CreateCloudBlobClient（）；
CloudBlobContainer container=blobClient.GetContainerReference（文件夹）；
CloudBlockBlob blockBlob=null；
if（！MultipartRequestHelper.IsMultipartContentType（request.ContentType））
{
抛出新异常（$“应为多部分请求，但得到{request.ContentType}”）；
}
var formAccumulator=新的KeyValueAccumulator（）；
var boundary=MultipartRequestHelper.GetBoundary(
MediaTypeHeaderValue.Parse（request.ContentType），
DefaultFormOptions.MultipartBoundaryLengthLimit）；
var reader=新的MultipartReader（boundary，request.Body）；
var section=await reader.ReadNextSectionAsync（）；
while（节！=null）
{
contentdispositionheadervaluecontentdisposition；
var hasContentDispositionHeader=ContentDispositionHeaderValue.TryParse（section.ContentDisposition，out ContentDisposition）；
var disposition=ContentDispositionHeaderValue.Parse（section.ContentDisposition）；
if（hasContentDispositionHeader）
{
if（MultipartRequestHelper.HasFileContentDisposition（contentDisposition））
{
尝试
{
字符串fileName=HttpUtility.UrlEncode（disposition.fileName.Value.Replace（“\”，”），Encoding.UTF8）；
blockBlob=container.GetBlockBlobReference（Guid.NewGuid（）.ToString（））；
blockBlob.Properties.ContentType=GetMimeTypeByWindowsRegistry（文件名）；
blockBlob.Properties.ContentDisposition=“附件；文件名*=UTF-8”“”+文件名；
等待blockBlob.UploadFromStreamAsync（section.Body）；
}
捕获（例外e）
{
控制台写入线（e）；
投掷；
}
}
else if（MultipartRequestHelper.HasFormDataContentDisposition（contentDisposition））
{
var key=HeaderUtilities.RemoveQuotes（contentDisposition.Name）；
var encoding=GetEncoding（节）；
使用（var streamReader=newstreamreader）(
第三节正文，
编码，
detectEncodingFromByteOrderMarks:真，
缓冲区大小：1024，
（开：对）
{
var value=wait streamReader.ReadToEndAsync（）；
if（String.Equals（值，“未定义”，StringComparison.OrdinalIgnoreCase））
{
value=String.Empty；
}
formAccumulator.Append（key.Value，Value）；
if（formAccumulator.ValueCount>DefaultFormOptions.ValueCountLimit）
{
抛出新的InvalidDataException（$“超出了表单键计数限制{DefaultFormOptions.ValueCountLimit}”）；
}
}
}
}
section=wait reader.ReadNextSectionAsync（）；
}
var formValueProvider=新的formValueProvider(
BindingSource.Form，
新建FormCollection（formAccumulator.GetResults（）），
文化信息（当前文化）；
返回新的HttpResponseUploadClass{FormValueProvider=FormValueProvider，Url=blockBlob？.Uri.ToString（）}；
}

正如您所说，每个blob可以是不同的大小，最大为100MB（对于2016-05-31之前使用REST版本的请求，最大为4MB），一个blob最多可以包含50000个blob

如果您正在写入的块blob大小不超过256 MB（对于2016-05-31之前使用REST版本的请求，为64 MB），则可以通过一次写入操作将其全部上载到，请参阅

存储客户端默认为最大单块上载32MB，可使用

singleblobuploaddthresholdinbytes

属性进行设置。 当块blob上载大于此属性中的值时，选择stor

BlobRequestOptions requestoptions = new BlobRequestOptions()
{
    SingleBlobUploadThresholdInBytes = 1024 * 1024 * 50, //50MB
    ParallelOperationThreadCount = 12,
};

CloudStorageAccount account = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
CloudBlobClient blobclient = account.CreateCloudBlobClient();
blobclient.DefaultRequestOptions = requestoptions;
CloudBlobContainer blobcontainer = blobclient.GetContainerReference("uploadfiles");
blobcontainer.CreateIfNotExists();
CloudBlockBlob blockblob = blobcontainer.GetBlockBlobReference("bigfiles");