Asp.net mvc HttpContent不包含ReadAsMultipartAsync的定义

我正在使用VS2015创建一个WebApi项目。具体地说，我正在尝试编写一个简单的web服务来使用POST上传文件

在使用以前版本的Visual Studio之前，我已经这样做了，但是VS2015使用了ASP.NET 5和MVC 6，这显然有一些重大的api更改

以前，我可以用这样的东西：

Request.Content.ReadAsMultipartAsync().Result.Contents

顺便说一句，这是我搜索过的每个网站推荐的。但我的VS2015副本给了我以下编译时错误消息：

'HttpContent不包含ReadAsMultipartAsync的定义'

WebApi的总体项目结构似乎在VS2015中进行了修改。在这一点上，我不知道出了什么问题（无论是代码问题还是VS2015问题）。过去几天我一直在努力解决这个问题。有人能提供我做错了什么的见解吗

以下是我的控制器的全部内容：

    [Route("api/[controller]")]
public class UploadController : Controller
{
    private readonly IApplicationEnvironment appEnvironment;

    public UploadController(IApplicationEnvironment appEnvironment)
    {
        this.appEnvironment = appEnvironment;
    }

    // POST api/values
    [HttpPost]
    public void Post(HttpRequestMessage request)
    {
        string logFolder = "logs";
        string fileName = "uploader.log";
        string logFile = Path.Combine(this.appEnvironment.ApplicationBasePath, logFolder, fileName);
        string directory = Path.GetDirectoryName(logFile);

        if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
        {
            Directory.CreateDirectory(directory);
        }

        using (Stream requestStream = GetStreamFromUploadedFile(request))
        {
            using (Stream fileStream = System.IO.File.Create(logFile))
            {
                try
                {
                    requestStream.CopyTo(fileStream);
                }
                finally
                {
                    // No longer supported?
                    //fileStream.Close();
                    //requestStream.Close();
                }
            }
        }

    }

    private static Stream GetStreamFromUploadedFile(HttpRequestMessage request)
    {
        IEnumerable<HttpContent> parts = null;
        Task.Factory
            .StartNew(() => parts = request.Content.ReadAsMultipartAsync().Result.Contents,
                            CancellationToken.None,
                            TaskCreationOptions.LongRunning,
                            TaskScheduler.Default)
            .Wait();

        Stream stream = null;
        Task.Factory
            .StartNew(() => stream = parts.First().ReadAsStreamAsync().Result,
                            CancellationToken.None,
                            TaskCreationOptions.LongRunning,
                            TaskScheduler.Default)
            .Wait();
        return stream;
    }
}

[路由（“api/[控制器]”）]
公共类上载控制器：控制器
{
私有只读IApplicationEnvironment外观环境；
公共上传控制器（IApplicationEnvironment appEnvironment）
{
this.appEnvironment=appEnvironment；
}
//后api/值
[HttpPost]
公共无效Post（HttpRequestMessage请求）
{
字符串logFolder=“logs”；
string fileName=“uploader.log”；
字符串logFile=Path.Combine（this.appEnvironment.ApplicationBasePath，logFolder，fileName）；
string directory=Path.GetDirectoryName（日志文件）；
如果（！string.IsNullOrEmpty（directory）&&！directory.Exists（directory））
{
CreateDirectory（目录）；
}
使用（Stream requestStream=GetStreamFromUploadedFile（请求））
{
使用（Stream fileStream=System.IO.File.Create（logFile））
{
尝试
{
CopyTo（fileStream）；
}
最后
{
//不再支持？
//fileStream.Close（）；
//requestStream.Close（）；
}
}
}
}
私有静态流GetStreamFromUploadedFile（HttpRequestMessage请求）
{
IEnumerable parts=null；
任务，工厂
.StartNew（（）=>parts=request.Content.ReadAsMultipartAsync（）.Result.Contents，
取消令牌。无，
TaskCreationOptions.LongRunning，
TaskScheduler.Default）
.Wait（）；
Stream=null；
任务，工厂
.StartNew（（）=>stream=parts.First（）.ReadAsStreamAsync（）.Result，
取消令牌。无，
TaskCreationOptions.LongRunning，
TaskScheduler.Default）
.Wait（）；
回流；
}
}

以下是一个如何在ASP.NET 5/MVC 6中上载文件的示例：

使用System.Collections.Generic；
使用System.IO；
使用System.Linq；
使用Microsoft.AspNet.Mvc；
使用Microsoft.AspNet.Http；
使用Microsoft.Net.Http.Header；
使用ModelBindingWebSite.Models；
命名空间ModelBindingWebSite.Controllers
{
公共类FileUploadController:控制器
{
公共文件详细信息上载单个（IFormFile文件）
{
文件详情文件详情；
使用（var reader=newstreamreader（file.OpenReadStream（）））
{
var fileContent=reader.ReadToEnd（）；
var parsedContentDisposition=ContentDispositionHeaderValue.Parse（file.ContentDisposition）；
fileDetails=新的fileDetails
{
Filename=parsedContentDisposition.Filename，
内容=文件内容
};
}
返回文件详细信息；
}
公共文件详细信息[]上载多个（IEnumerable文件）
{
var fileDetailsList=新列表（）；
foreach（文件中的var文件）
{
var parsedContentDisposition=ContentDispositionHeaderValue.Parse（file.ContentDisposition）；
使用（var reader=newstreamreader（file.OpenReadStream（）））
{
var fileContent=reader.ReadToEnd（）；
var fileDetails=newfiledetails
{
Filename=parsedContentDisposition.Filename，
内容=文件内容
};
fileDetailsList.Add（fileDetails）；
}
}
返回fileDetailsList.ToArray（）；
}
公共IDictionary UploadMultipleList（IEnumerable filelist1，
IEnumerable文件列表2）
{
var fileDetailsDict=新字典
{
{“filelist1”，new List（）}，
{“filelist2”，new List（）}
};
var fileDetailsList=新列表（）；
foreach（filelist1.Concat（filelist2）中的var文件）
{
var parsedContentDisposition=ContentDispositionHeaderValue.Parse（file.ContentDisposition）；
使用（var reader=newstreamreader（file.OpenReadStream（）））
{
var fileContent=reader.ReadToEnd（）；
var fileDetails=newfiledetails
{
Filename=parsedContentDisposition.Filename，
内容=文件内容
};
fileDetailsDict[parsedContentDisposition.Name]。添加（fileDetails）；
}
}
返回文件详情信息；
}
public KeyValuePair UploadModelWithFile（书本）
{
var file=book.file；
变量读取器=新的StreamReader（f
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Microsoft.AspNet.Mvc;
using Microsoft.AspNet.Http;
using Microsoft.Net.Http.Headers;
using ModelBindingWebSite.Models;

namespace ModelBindingWebSite.Controllers
{
    public class FileUploadController : Controller
    {
        public FileDetails UploadSingle(IFormFile file)
        {
            FileDetails fileDetails;
            using (var reader = new StreamReader(file.OpenReadStream()))
            {
                var fileContent = reader.ReadToEnd();
                var parsedContentDisposition = ContentDispositionHeaderValue.Parse(file.ContentDisposition);
                fileDetails = new FileDetails
                {
                    Filename = parsedContentDisposition.FileName,
                    Content = fileContent
                };
            }

            return fileDetails;
        }

        public FileDetails[] UploadMultiple(IEnumerable<IFormFile> files)
        {
            var fileDetailsList = new List<FileDetails>();
            foreach (var file in files)
            {
                var parsedContentDisposition = ContentDispositionHeaderValue.Parse(file.ContentDisposition);
                using (var reader = new StreamReader(file.OpenReadStream()))
                {
                    var fileContent = reader.ReadToEnd();
                    var fileDetails = new FileDetails
                    {
                        Filename = parsedContentDisposition.FileName,
                        Content = fileContent
                    };
                    fileDetailsList.Add(fileDetails);
                }
            }

            return fileDetailsList.ToArray();
        }

        public IDictionary<string, IList<FileDetails>> UploadMultipleList(IEnumerable<IFormFile> filelist1,
                                                                     IEnumerable<IFormFile> filelist2)
        {
            var fileDetailsDict = new Dictionary<string, IList<FileDetails>>
            {
                { "filelist1", new List<FileDetails>() },
                { "filelist2", new List<FileDetails>() }
            };
            var fileDetailsList = new List<FileDetails>();
            foreach (var file in filelist1.Concat(filelist2))
            {
                var parsedContentDisposition = ContentDispositionHeaderValue.Parse(file.ContentDisposition);
                using (var reader = new StreamReader(file.OpenReadStream()))
                {
                    var fileContent = reader.ReadToEnd();
                    var fileDetails = new FileDetails
                    {
                        Filename = parsedContentDisposition.FileName,
                        Content = fileContent
                    };
                    fileDetailsDict[parsedContentDisposition.Name].Add(fileDetails);
                }
            }

            return fileDetailsDict;
        }

        public KeyValuePair<string, FileDetails> UploadModelWithFile(Book book)
        {
           var file = book.File;
            var reader = new StreamReader(file.OpenReadStream());
            var fileContent = reader.ReadToEnd();
            var parsedContentDisposition = ContentDispositionHeaderValue.Parse(file.ContentDisposition);
            var fileDetails = new FileDetails
            {
                Filename = parsedContentDisposition.FileName,
                Content = fileContent
            };

            return new KeyValuePair<string, FileDetails>(book.Name, fileDetails);
        }
    }
}