private async Task<IFormCollection> InnerReadFormAsync(CancellationToken cancellationToken)
{
    FormFileCollection? files = null;
    using (cancellationToken.Register((state) => ((HttpContext)state!).Abort(), _request.HttpContext))
    {
        var contentType = ContentType;
        // 判断ContentType为multipart/form-data的时候
        if (HasMultipartFormContentType(contentType))
        {
            var formAccumulator = new KeyValueAccumulator();

            //得到boundary数据
            //Content-Type: multipart/form-data; boundary="----WebKitFormBoundarymx2fSWqWSd0OxQqq"
            var boundary = GetBoundary(contentType, _options.MultipartBoundaryLengthLimit);
            // 把针对文件上传的部分封装到MultipartReader
            var multipartReader = new MultipartReader(boundary, _request.Body)
            {
                //Header个数限制
                HeadersCountLimit = _options.MultipartHeadersCountLimit,
                //Header长度限制
                HeadersLengthLimit = _options.MultipartHeadersLengthLimit,
                //Body长度限制
                BodyLengthLimit = _options.MultipartBodyLengthLimit,
            };

            //获取下一个可解析的节点,可以理解为每一个要解析的上传文件信息
            var section = await multipartReader.ReadNextSectionAsync(cancellationToken);
            //不为null说明已从Body解析出的上传文件信息
            while (section != null)
            {
                // 在这里解析内容配置并进一步传递它以避免重新分析
                if (!ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out var contentDisposition))
                {
                    throw new InvalidDataException("");
                }

                if (contentDisposition.IsFileDisposition())
                {
                    var fileSection = new FileMultipartSection(section, contentDisposition);
                    // 如果尚未对整个正文执行缓冲，则为文件启用缓冲
                    section.EnableRewind(
                        _request.HttpContext.Response.RegisterForDispose,
                        _options.MemoryBufferThreshold, _options.MultipartBodyLengthLimit);

                    // 找到结尾
                    await section.Body.DrainAsync(cancellationToken);

                    var name = fileSection.Name;
                    var fileName = fileSection.FileName;

                    FormFile file;
                    //判断Body默认的流是否被修改过,比如开启缓冲就会修改
                    //如果Body不是默认流则直接服务Body
                    if (section.BaseStreamOffset.HasValue)
                    {
                        file = new FormFile(_request.Body, section.BaseStreamOffset.GetValueOrDefault(), section.Body.Length, name, fileName);
                    }
                    else
                    {
                        // 如果没有被修改过则获取MultipartReaderStream的实例
                        file = new FormFile(section.Body, 0, section.Body.Length, name, fileName);
                    }
                    file.Headers = new HeaderDictionary(section.Headers);

                    //如果解析出来了文件信息则初始化FormFileCollection
                    if (files == null)
                    {
                        files = new FormFileCollection();
                    }
                    if (files.Count >= _options.ValueCountLimit)
                    {
                        throw new InvalidDataException("");
                    }
                    files.Add(file);
                }
                else if (contentDisposition.IsFormDisposition())
                {
                    var formDataSection = new FormMultipartSection(section, contentDisposition);

                    var key = formDataSection.Name;
                    var value = await formDataSection.GetValueAsync();

                    formAccumulator.Append(key, value);
                    if (formAccumulator.ValueCount > _options.ValueCountLimit)
                    {
                        throw new InvalidDataException("");
                    }
                }
                else
                {
                    //没解析出来类型
                }
                section = await multipartReader.ReadNextSectionAsync(cancellationToken);
            }

            if (formAccumulator.HasValues)
            {
                formFields = new FormCollection(formAccumulator.GetResults(), files);
            }
        }
    }

    // 如果可重置,则恢复读取位置为0(因为Body被读取到了尾部)
    if (_request.Body.CanSeek)
    {
        _request.Body.Seek(0, SeekOrigin.Begin);
    }

    //通过files得到FormCollection
    if (files != null)
    {
        Form = new FormCollection(null, files);
    }
    return Form;
}

这部分源码比较多，而且这还是精简过只剩下ContentType为multipart/form-data的内容，不过从这里我们就可以看出来FormFile的实例确实是依靠Request的Body里。其核心就在MultipartReader类的ReadNextSectionAsync方法返回的Section数据[点击查看源码??]通过上面的循环可以看到它是循环读取的，它通过解析Request信息持续的迭代MultipartSection信息,这种操作方式正是处理一次上传存在多个文件的情况,具体操作如下所示

private readonly BufferedReadStream _stream;
private readonly MultipartBoundary _boundary;
private MultipartReaderStream _currentStream;

public MultipartReader(string boundary, Stream stream, int bufferSize)
{
    //stream即是传递下来的RequestBody
    _stream = new BufferedReadStream(stream, bufferSize);
    _boundary = new MultipartBoundary(boundary, false);
    //创建MultipartReaderStream实例
    _currentStream = new MultipartReaderStream(_stream, _boundary) { LengthLimit = HeadersLengthLimit };
}

public async Task<MultipartSection?> ReadNextSectionAsync(CancellationToken cancellationToken = new CancellationToken())
{
    //清空上一个节点的信息
    await _currentStream.DrainAsync(cancellationToken);
    // 如果返回了空值表示为最后一个节点
    if (_currentStream.FinalBoundaryFound)
    {
        // 清空最后一个节点的挂载数据
        await _stream.DrainAsync(HeadersLengthLimit, cancellationToken);
        return null;
    }
    //读取header信息
    var headers = await ReadHeadersAsync(cancellationToken);
    _boundary.ExpectLeadingCrlf = true;
    //组装MultipartReaderStream实例
    _currentStream = new MultipartReaderStream(_stream, _boundary) { LengthLimit = BodyLengthLimit };
    //判断流是否是原始的HttpRequestStream
    long? baseStreamOffset = _stream.CanSeek ? (long?)_stream.Position : null;
    //通过上面信息构造MultipartSection实例
    return new MultipartSection() { Headers = headers, Body = _currentStream, BaseStreamOffset = baseStreamOffset };
}

这里可以看出传递下来的RequestBody被构建出了MultipartReaderStream实例,即MultipartReaderStream包装了RequestBody中的信息[点击查看源码??]看名字也知道它也是实现了Stream抽象类

internal sealed class MultipartReaderStream : Stream
{
}

而且我们看到BodyLengthLimit正是传递给了它的LengthLimit属性,而BodyLengthLimit正是设置限制上传文件的大小的属性，我们找到使用LengthLimit属性的地方，代码如下所示[点击查看源码??]

private int UpdatePosition(int read)
{
    //更新Stream的Position的值,即更新读取位置
    _position += read;
    //继续读取
    if (_observedLength < _position)
    {
        //保存已经读取了的位置
        _observedLength = _position;
        //如果读取了位置大于LengthLimit则抛出异常
        if (LengthLimit.HasValue && _observedLength > LengthLimit.GetValueOrDefault())
        {
            throw new InvalidDataException($"Multipart body length limit {LengthLimit.GetValueOrDefault()} exceeded.");
        }
    }
    return read;
}

从这段代码我们可以看出，正是此方法限制了读取的Body大小，通过我们对Stream的了解，这个UpdatePosition方法也必然会在Stream的Read方法也即是此处的MultipartReaderStream的Read方法中调用[点击查看源码??]这样才能起到限制的作用,大致看一下Read方法的实现代码

public override int Read(byte[] buffer, int offset, int count)
{
    //如果已经读到了结尾则直接返回0
    if (_finished)
    {
        return 0;
    }
    PositionInnerStream();
    var bufferedData = _innerStream.BufferedData;
    // 匹配boundary的读取边界
    int read;
    if (SubMatch(bufferedData, _boundary.BoundaryBytes, out var matchOffset, out var matchCount))
    {
        // 匹配到了可读取的边界读取并返回
        if (matchOffset > bufferedData.Offset)
        {
            read = _innerStream.Read(buffer, offset, Math.Min(count, matchOffset - bufferedData.Offset));
            //返回读取的长度正是调用的UpdatePosition
            return UpdatePosition(read);
        }

        var length = _boundary.BoundaryBytes.Length;
        Debug.Assert(matchCount == length);

        var boundary = _bytePool.Rent(length);
        read = _innerStream.Read(boundary, 0, length);
        _bytePool.Return(boundary);
        Debug.Assert(read == length);

        //读取RequestBody信息
        var remainder = _innerStream.ReadLine(lengthLimit: 100);
        remainder = remainder.Trim();
        //说明读取到了boundary的结尾
        if (string.Equals("--", remainder, StringComparison.Ordinal))
        {
            FinalBoundaryFound = true;
        }
        Debug.Assert(FinalBoundaryFound || string.Equals(string.Empty, remainder, StringComparison.Ordinal), "Un-expected data found on the boundary line: " + remainder);
        _finished = true;
        //返回读取的长度0说明读到了结尾
        return 0;
    }
    read = _innerStream.Read(buffer, offset, Math.Min(count, bufferedData.Count));
    //这里同样是UpdatePosition
    return UpdatePosition(read);
}

通过这里就可清楚的看到MultipartReaderStream的Read方法就是在解析读取的RequestBody的FormData类型的信息，解析成我们可以直接读取或者直接保存成文件的的原始的文件信息，它还有一个异步读取的ReadAsync方法其实现原理类似，在这里咱们就不在展示源码了。最后我们再来看一下MultipartSection类的实现[点击查看源码??]我们上面知道了MultipartReaderStream才是在RequestBody中解析到文件上传信息的关键所在,因此MultipartSection也就是包装了读取好的文件信息,我们来看一下它的代码实现

public class MultipartSection
{
    /// <summary>
    /// 从header中得到的ContentType类型
    /// </summary>
    public string? ContentType
    {
        get
        {
            if (Headers != null && Headers.TryGetValue(HeaderNames.ContentType, out var values))
            {
                return values;
            }
            return null;
        }
    }

    /// <summary>
    /// 从header中得到的ContentDisposition信息
    /// </summary>
    public string? ContentDisposition
    {
        get
        {
            if (Headers != null && Headers.TryGetValue(HeaderNames.ContentDisposition, out var values))
            {
                return values;
            }
            return null;
        }
    }

    /// <summary>
    /// 读取到的Header信息
    /// </summary>
    public Dictionary<string, StringValues>? Headers { get; set; }

    /// <summary>
    /// 从RequestBody中解析到的Stream信息，即MultipartReaderStream或其他RequestBody实例
    /// </summary>
    public Stream Body { get; set; } = default!;

    /// <summary>
    /// 已经被读取过的Stream位置
    /// </summary>
    public long? BaseStreamOffset { get; set; }
}

不出所料，这个类正是包装了上面一堆针对HTTP请求信息中读取到的关于上传的文件信息，由于上面设计到了几个类，而且设计到了一个大致的读取流程，为了防止同学们看起来容易蒙圈，这里咱们大致总结一下这里的读取流程。通过上面的代码我们了解到了涉及到的几个重要的类MultipartReader、MultipartReaderStream、MultipartSection知道这几个类在做什么就能明白到底是怎么通过RequestBody解析到文件信息的。大致解释一下这几个类在做些什么

• 通过MultipartReader类的ReadNextSectionAsync方法可以得到MultipartSection的实例
• MultipartSection类包含的就是解析出RequestBody里的文件相关的信息包装起来，MultipartSection的Body属性的值正是MultipartReaderStream的实例。
• MultipartReaderStream类正是通过读取RequestBody里的各种boundary信息转换为原始的文件内容的Stream信息
• FormFile的CopyToAsync和OpenReadStream方法都是Stream操作，而操作的Stream是来自MultipartReaderStream实例

总结

    这次的分析差不多就到这里了, 本篇文章主要讨论了ASP.NET Core文件上传操作类IFormFile与RequestBody的关系，即如果通过RequestBody得到IFormFile实例相关，毕竟是源码设计到的东西比较多也比较散乱，我们再来大致的总结一下

• 无论在Action上对IFormFile、List<IFormFile>、IFormFileCollection等进行模型绑定，其实都是来自模型绑定处理类FormFileModelBinder，而这个类正是根据Request.Form.File的处理来判断如何进行模型绑定的。
• 而Request.Form.File本身其实就是IFormFileCollection类型的，它的值也正是来自对RequestBody的解析，也正是我们今天的结论File的值来自RequestBody。
• 从RequestBody解析到IFormFileCollection是一个过程，而IFormFileCollection实际上是IFormFile的集合类型，从RequestBody解析出来的也是单个IFormFile类型，通过不断的迭代添加得到的IFormFileCollection集合。
• 而从RequestBody中解析出来上传的文件到IFormFile涉及到了几个核心类，即MultipartReader、MultipartReaderStream和MultipartSection。其中MultipartSection是通过MultipartReader的ReadNextSectionAsync方法得到的，里面包含了解析好的上传文件相关信息。而MultipartSection正是包装了MultipartReaderStream，而这个类才是真正读取RequestBody得到可读取的文件原始Stream的关键所在。

到了这里本文的全部内容就差不多结束了，希望本文能给大家带来收获。我觉得有时候看源码能解决许多问题和心中的疑惑，因为我们作为程序员每天写的也就是代码，所以没有比程序员直接读取代码能更好的了解想了解的信息了。但是读源码也有一定的困难，毕竟是别人的代码，思维存在一定的偏差，更何况是一些优秀的框架，作者们的思维很可能比我们要高出很多，所以很多时候读起来会非常的吃力，即便如此笔者也觉得读源码是了解框架得到框架信息的一种比较行之有效的方式。

??欢迎扫码关注我的公众号??

bk

上一篇：iPhone12容易发热是什么原因 iPhone12如何如何避免发热

下一篇：没有了