public class StreamContent : HttpContent
{// Fieldsprivate int bufferSize;private Stream content;private bool contentConsumed;private const int defaultBufferSize = 0x1000;private long start;// Methodspublic StreamContent(Stream content);
]public StreamContent(Stream content, int bufferSize);protected override Task<Stream> CreateContentReadStreamAsync();protected override void Dispose(bool disposing);private void PrepareContent();protected override Task SerializeToStreamAsync(Stream stream, TransportContext context);protected internal override bool TryComputeLength(out long length);// Nested Typesprivate class ReadOnlyStream : DelegatingStream{......}
}

 private const int defaultBufferSize = 0x1000;

 public StreamContent(Stream content, int bufferSize);

  var response = new HttpResponseMessage();response.Content = new StreamContent(fileStream);

 private const int BufferSize = 80 * 1024;response.Content = new StreamContent(fileStream, BufferSize);

     /// <summary>/// Provides an implementation of <see cref="IHostBufferPolicySelector"/> suited for use/// in an ASP.NET environment which provides direct support for input and output buffering./// </summary>public class WebHostBufferPolicySelector : IHostBufferPolicySelector{....../// <summary>/// Determines whether the host should buffer the <see cref="HttpResponseMessage"/> entity body./// </summary>/// <param name="response">The <see cref="HttpResponseMessage"/>response for which to determine/// whether host output buffering should be used for the response entity body.</param>/// <returns><c>true</c> if buffering should be used; otherwise a streamed response should be used.</returns>public virtual bool UseBufferedOutputStream(HttpResponseMessage response){if (response == null){throw Error.ArgumentNull("response");}// Any HttpContent that knows its length is presumably already buffered internally.HttpContent content = response.Content;if (content != null){long? contentLength = content.Headers.ContentLength;if (contentLength.HasValue && contentLength.Value >= 0){return false;}// Content length is null or -1 (meaning not known).  // Buffer any HttpContent except StreamContent and PushStreamContentreturn !(content is StreamContent || content is PushStreamContent);}return false;}}

 return !(content is StreamContent || content is PushStreamContent);

  /// <summary>/// Provides an <see cref="HttpContent"/> implementation that exposes an output <see cref="Stream"/>/// which can be written to directly. The ability to push data to the output stream differs from the /// <see cref="StreamContent"/> where data is pulled and not pushed./// </summary>public class PushStreamContent : HttpContent{private readonly Func<Stream, HttpContent, TransportContext, Task> _onStreamAvailable;/// <summary>/// Initializes a new instance of the <see cref="PushStreamContent"/> class. The/// <paramref name="onStreamAvailable"/> action is called when an output stream/// has become available allowing the action to write to it directly. When the /// stream is closed, it will signal to the content that is has completed and the /// HTTP request or response will be completed./// </summary>/// <param name="onStreamAvailable">The action to call when an output stream is available.</param>public PushStreamContent(Action<Stream, HttpContent, TransportContext> onStreamAvailable): this(Taskify(onStreamAvailable), (MediaTypeHeaderValue)null){}
......}

response.Content = new StreamContent(File.OpenRead(filePath));

XDocument xDoc = XDocument.Load("cnblogs_backup.xml", LoadOptions.None);
PushStreamContent xDocContent = new PushStreamContent(
(stream, content, context) =>
{xDoc.Save(stream);stream.Close();
},
"application/xml");

    var client = new HttpClient();string json = JsonConvert.SerializeObject(data);var response = await client.PostAsync(uri, new StringContent(json));

    var client = new HttpClient();var content = new PushStreamContent((stream, httpContent, transportContext) =>{var serializer = new JsonSerializer();using (var writer = new StreamWriter(stream)){serializer.Serialize(writer, data);}});var response = await client.PostAsync(uri, content);

  protected override Task SerializeToStreamAsync(Stream stream, TransportContext context);

request.Headers.Range

 RangeItemHeaderValue range = rangeHeader.Ranges.First();

range.From.HasValue
range.To.HasValue

    public interface IFileProvider{bool Exists(string name);FileStream Open(string name);long GetLength(string name);}

    public class FileProvider : IFileProvider{private readonly string _filesDirectory;private const string AppSettingsKey = "DownloadDir";public FileProvider(){var fileLocation = ConfigurationManager.AppSettings[AppSettingsKey];if (!String.IsNullOrWhiteSpace(fileLocation)){_filesDirectory = fileLocation;}}/// <summary>/// 判断文件是否存在/// </summary>/// <param name="name"></param>/// <returns></returns>public bool Exists(string name){string file = Directory.GetFiles(_filesDirectory, name, SearchOption.TopDirectoryOnly).FirstOrDefault();return true;}/// <summary>/// 打开文件/// </summary>/// <param name="name"></param>/// <returns></returns>public FileStream Open(string name){var fullFilePath = Path.Combine(_filesDirectory, name);return File.Open(fullFilePath,FileMode.Open, FileAccess.Read, FileShare.Read);}/// <summary>/// 获取文件长度/// </summary>/// <param name="name"></param>/// <returns></returns>public long GetLength(string name){var fullFilePath = Path.Combine(_filesDirectory, name);return new FileInfo(fullFilePath).Length;}}

    public class FileInfo{public long From;public long To;public bool IsPartial;public long Length;}

    public class FileDownloadController : ApiController{private const int BufferSize = 80 * 1024;private const string MimeType = "application/octet-stream";public IFileProvider FileProvider { get; set; }public FileDownloadController(){FileProvider = new FileProvider();}......}

            if (!FileProvider.Exists(fileName)){throw new HttpResponseException(HttpStatusCode.NotFound);}long fileLength = FileProvider.GetLength(fileName);

        private FileInfo GetFileInfoFromRequest(HttpRequestMessage request, long entityLength){var fileInfo = new FileInfo{From = 0,To = entityLength - 1,IsPartial = false,Length = entityLength};var rangeHeader = request.Headers.Range;if (rangeHeader != null && rangeHeader.Ranges.Count != 0){if (rangeHeader.Ranges.Count > 1){throw new HttpResponseException(HttpStatusCode.RequestedRangeNotSatisfiable);}RangeItemHeaderValue range = rangeHeader.Ranges.First();if (range.From.HasValue && range.From < 0 || range.To.HasValue && range.To > entityLength - 1){throw new HttpResponseException(HttpStatusCode.RequestedRangeNotSatisfiable);}fileInfo.From = range.From ?? 0;fileInfo.To = range.To ?? entityLength - 1;fileInfo.IsPartial = true;fileInfo.Length = entityLength;if (range.From.HasValue && range.To.HasValue){fileInfo.Length = range.To.Value - range.From.Value + 1;}else if (range.From.HasValue){fileInfo.Length = entityLength - range.From.Value + 1;}else if (range.To.HasValue){fileInfo.Length = range.To.Value + 1;}}return fileInfo;}

         private void SetResponseHeaders(HttpResponseMessage response, FileInfo fileInfo,long fileLength, string fileName){response.Headers.AcceptRanges.Add("bytes");response.StatusCode = fileInfo.IsPartial ? HttpStatusCode.PartialContent: HttpStatusCode.OK;response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment");response.Content.Headers.ContentDisposition.FileName = fileName;response.Content.Headers.ContentType = new MediaTypeHeaderValue(MimeType);response.Content.Headers.ContentLength = fileInfo.Length;if (fileInfo.IsPartial){response.Content.Headers.ContentRange= new ContentRangeHeaderValue(fileInfo.From, fileInfo.To, fileLength);}}

    public class PartialContentFileStream : Stream{private readonly long _start;private readonly long _end;private long _position;private FileStream _fileStream;public PartialContentFileStream(FileStream fileStream, long start, long end){_start = start;_position = start;_end = end;_fileStream = fileStream;if (start > 0){_fileStream.Seek(start, SeekOrigin.Begin);}}/// <summary>/// 将缓冲区数据写到文件/// </summary>public override void Flush(){_fileStream.Flush();}/// <summary>/// 设置当前下载位置/// </summary>/// <param name="offset"></param>/// <param name="origin"></param>/// <returns></returns>public override long Seek(long offset, SeekOrigin origin){if (origin == SeekOrigin.Begin){_position = _start + offset;return _fileStream.Seek(_start + offset, origin);}else if (origin == SeekOrigin.Current){_position += offset;return _fileStream.Seek(_position + offset, origin);}else{throw new NotImplementedException("SeekOrigin.End未实现");}}/// <summary>/// 依据偏离位置读取/// </summary>/// <param name="buffer"></param>/// <param name="offset"></param>/// <param name="count"></param>/// <returns></returns>public override int Read(byte[] buffer, int offset, int count){int byteCountToRead = count;if (_position + count > _end){byteCountToRead = (int)(_end - _position) + 1;}var result = _fileStream.Read(buffer, offset, byteCountToRead);_position += byteCountToRead;return result;}public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state){int byteCountToRead = count;if (_position + count > _end){byteCountToRead = (int)(_end - _position);}var result = _fileStream.BeginRead(buffer, offset,count, (s) =>{_position += byteCountToRead;callback(s);}, state);return result;}......}

        public HttpResponseMessage GetFile(string fileName){fileName = "HBuilder.windows.5.2.6.zip";if (!FileProvider.Exists(fileName)){throw new HttpResponseException(HttpStatusCode.NotFound);}long fileLength = FileProvider.GetLength(fileName);var fileInfo = GetFileInfoFromRequest(this.Request, fileLength);var stream = new PartialContentFileStream(FileProvider.Open(fileName),fileInfo.From, fileInfo.To);var response = new HttpResponseMessage();response.Content = new StreamContent(stream, BufferSize);SetResponseHeaders(response, fileInfo, fileLength, fileName);return response;}