public ActionResult Get(string filename)
{
FileEntity fileEntity = GetFileInfo(filename);
string fileFullPath = System.IO.Path.Combine(@"C:\", fileEntity.file_path, filename);
if (fileEntity == null)
return NotFound();
FileStream fileStream = System.IO.File.Open(fileFullPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
long startByteIndex = 0;
long endByteIndex = fileEntity.file_length-1;
var reqTypedHeader = Request.GetTypedHeaders();
if (reqTypedHeader.Range!=null && reqTypedHeader.Range.Ranges.Count>0)
{
//断点续传处理，多range情景没有处理
startByteIndex = reqTypedHeader.Range.Ranges.First().From ?? 0;
endByteIndex = reqTypedHeader.Range.Ranges.First().To ?? fileEntity.file_length - 1;
Response.StatusCode = StatusCodes.Status206PartialContent;
var contentRange = new ContentRangeHeaderValue(startByteIndex, endByteIndex);
Response.Headers[HeaderNames.ContentRange] = contentRange.ToString();
}
Response.ContentType = fileEntity.file_mimetype;
var contentDisposition = new ContentDispositionHeaderValue("attachment");
contentDisposition.SetHttpFileName(fileEntity.file_name);
Response.Headers[HeaderNames.ContentDisposition] = contentDisposition.ToString();
Response.ContentLength = fileStream.Length;
Response.Headers[HeaderNames.AcceptRanges] = "bytes";
return new FileStreamResult(fileStream,fileEntity.file_mimetype);
}
public void Ctor_LengthOnlyOverloadValidValues_ValuesCorrectlySet()
{
var range = new ContentRangeHeaderValue(5);
Assert.False(range.HasRange, "HasRange");
Assert.True(range.HasLength, "HasLength");
Assert.Equal("bytes", range.Unit);
Assert.Null(range.From);
Assert.Null(range.To);
Assert.Equal(5, range.Length);
}
public void Ctor_FromToAndLengthOverloadValidValues_ValuesCorrectlySet()
{
var range = new ContentRangeHeaderValue(0, 1, 2);
Assert.True(range.HasRange, "HasRange");
Assert.True(range.HasLength, "HasLength");
Assert.Equal("bytes", range.Unit);
Assert.Equal(0, range.From);
Assert.Equal(1, range.To);
Assert.Equal(2, range.Length);
}
public void Unit_GetAndSetValidAndInvalidValues_MatchExpectation()
{
var range = new ContentRangeHeaderValue(0);
range.Unit = "myunit";
Assert.Equal("myunit", range.Unit);
Assert.Throws<ArgumentException>(() => range.Unit = null);
Assert.Throws<ArgumentException>(() => range.Unit = "");
Assert.Throws<FormatException>(() => range.Unit = " x");
Assert.Throws<FormatException>(() => range.Unit = "x ");
Assert.Throws<FormatException>(() => range.Unit = "x y");
}
public void GetHashCode_UseSameAndDifferentRanges_SameOrDifferentHashCodes()
{
var range1 = new ContentRangeHeaderValue(1, 2, 5);
var range2 = new ContentRangeHeaderValue(1, 2);
var range3 = new ContentRangeHeaderValue(5);
var range4 = new ContentRangeHeaderValue(1, 2, 5);
range4.Unit = "BYTES";
var range5 = new ContentRangeHeaderValue(1, 2, 5);
range5.Unit = "myunit";
Assert.NotEqual(range1.GetHashCode(), range2.GetHashCode());
Assert.NotEqual(range1.GetHashCode(), range3.GetHashCode());
Assert.NotEqual(range2.GetHashCode(), range3.GetHashCode());
Assert.Equal(range1.GetHashCode(), range4.GetHashCode());
Assert.NotEqual(range1.GetHashCode(), range5.GetHashCode());
}
public void TryParse_SetOfInvalidValueStrings_ReturnsFalse(string?input)
{
Assert.False(ContentRangeHeaderValue.TryParse(input, out var result));
Assert.Null(result);
}
public void Parse_SetOfInvalidValueStrings_Throws(string?input)
{
Assert.Throws <FormatException>(() => ContentRangeHeaderValue.Parse(input));
}
private static int GetContentRangeLength(StringSegment input, int startIndex, out ContentRangeHeaderValue parsedValue)
{
Contract.Requires(startIndex >= 0);
parsedValue = null;
if (StringSegment.IsNullOrEmpty(input) || (startIndex >= input.Length))
{
return(0);
}
// Parse the unit string: <unit> in '<unit> <from>-<to>/<length>'
var unitLength = HttpRuleParser.GetTokenLength(input, startIndex);
if (unitLength == 0)
{
return(0);
}
var unit = input.Subsegment(startIndex, unitLength);
var current = startIndex + unitLength;
var separatorLength = HttpRuleParser.GetWhitespaceLength(input, current);
if (separatorLength == 0)
{
return(0);
}
current = current + separatorLength;
if (current == input.Length)
{
return(0);
}
// Read range values <from> and <to> in '<unit> <from>-<to>/<length>'
var fromStartIndex = current;
var fromLength = 0;
var toStartIndex = 0;
var toLength = 0;
if (!TryGetRangeLength(input, ref current, out fromLength, out toStartIndex, out toLength))
{
return(0);
}
// After the range is read we expect the length separator '/'
if ((current == input.Length) || (input[current] != '/'))
{
return(0);
}
current++; // Skip '/' separator
current = current + HttpRuleParser.GetWhitespaceLength(input, current);
if (current == input.Length)
{
return(0);
}
// We may not have a length (e.g. 'bytes 1-2/*'). But if we do, parse the length now.
var lengthStartIndex = current;
var lengthLength = 0;
if (!TryGetLengthLength(input, ref current, out lengthLength))
{
return(0);
}
if (!TryCreateContentRange(input, unit, fromStartIndex, fromLength, toStartIndex, toLength,
lengthStartIndex, lengthLength, out parsedValue))
{
return(0);
}
return(current - startIndex);
}
public void ToString_UseDifferentRanges_AllSerializedCorrectly()
{
var range = new ContentRangeHeaderValue(1, 2, 3);
range.Unit = "myunit";
Assert.Equal("myunit 1-2/3", range.ToString());
range = new ContentRangeHeaderValue(123456789012345678, 123456789012345679);
Assert.Equal("bytes 123456789012345678-123456789012345679/*", range.ToString());
range = new ContentRangeHeaderValue(150);
Assert.Equal("bytes */150", range.ToString());
}
public static bool TryParse(string input, out ContentRangeHeaderValue parsedValue)
{
var index = 0;
return Parser.TryParseValue(input, ref index, out parsedValue);
}
/// <summary>
/// Attempts to parse the specified <paramref name="input"/> as a <see cref="ContentRangeHeaderValue"/>.
/// </summary>
/// <param name="input">The value to parse.</param>
/// <param name="parsedValue">The parsed value.</param>
/// <returns><see langword="true"/> if input is a valid <see cref="ContentRangeHeaderValue"/>, otherwise <see langword="false"/>.</returns>
public static bool TryParse(StringSegment input, [NotNullWhen(true)] out ContentRangeHeaderValue parsedValue)
{
var index = 0;
return(Parser.TryParseValue(input, ref index, out parsedValue !));
}
private void CheckValidParse(string?input, ContentRangeHeaderValue expectedResult)
{
var result = ContentRangeHeaderValue.Parse(input);
Assert.Equal(expectedResult, result);
}
public void Equals_UseSameAndDifferentRanges_EqualOrNotEqualNoExceptions()
{
var range1 = new ContentRangeHeaderValue(1, 2, 5);
var range2 = new ContentRangeHeaderValue(1, 2);
var range3 = new ContentRangeHeaderValue(5);
var range4 = new ContentRangeHeaderValue(1, 2, 5);
range4.Unit = "BYTES";
var range5 = new ContentRangeHeaderValue(1, 2, 5);
range5.Unit = "myunit";
var range6 = new ContentRangeHeaderValue(1, 3, 5);
var range7 = new ContentRangeHeaderValue(2, 2, 5);
var range8 = new ContentRangeHeaderValue(1, 2, 6);
Assert.False(range1.Equals(null), "bytes 1-2/5 vs. <null>");
Assert.False(range1.Equals(range2), "bytes 1-2/5 vs. bytes 1-2/*");
Assert.False(range1.Equals(range3), "bytes 1-2/5 vs. bytes */5");
Assert.False(range2.Equals(range3), "bytes 1-2/* vs. bytes */5");
Assert.True(range1.Equals(range4), "bytes 1-2/5 vs. BYTES 1-2/5");
Assert.True(range4.Equals(range1), "BYTES 1-2/5 vs. bytes 1-2/5");
Assert.False(range1.Equals(range5), "bytes 1-2/5 vs. myunit 1-2/5");
Assert.False(range1.Equals(range6), "bytes 1-2/5 vs. bytes 1-3/5");
Assert.False(range1.Equals(range7), "bytes 1-2/5 vs. bytes 2-2/5");
Assert.False(range1.Equals(range8), "bytes 1-2/5 vs. bytes 1-2/6");
}
public void GetHashCode_UseSameAndDifferentRanges_SameOrDifferentHashCodes()
{
var range1 = new ContentRangeHeaderValue(1, 2, 5);
var range2 = new ContentRangeHeaderValue(1, 2);
var range3 = new ContentRangeHeaderValue(5);
var range4 = new ContentRangeHeaderValue(1, 2, 5);
range4.Unit = "BYTES";
var range5 = new ContentRangeHeaderValue(1, 2, 5);
range5.Unit = "myunit";
Assert.NotEqual(range1.GetHashCode(), range2.GetHashCode());
Assert.NotEqual(range1.GetHashCode(), range3.GetHashCode());
Assert.NotEqual(range2.GetHashCode(), range3.GetHashCode());
Assert.Equal(range1.GetHashCode(), range4.GetHashCode());
Assert.NotEqual(range1.GetHashCode(), range5.GetHashCode());
}
private static bool TryCreateContentRange(string input, string unit, int fromStartIndex, int fromLength,
int toStartIndex, int toLength, int lengthStartIndex, int lengthLength, out ContentRangeHeaderValue parsedValue)
{
parsedValue = null;
long from = 0;
if ((fromLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(fromStartIndex, fromLength), out from))
{
return(false);
}
long to = 0;
if ((toLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(toStartIndex, toLength), out to))
{
return(false);
}
// 'from' must not be greater than 'to'
if ((fromLength > 0) && (toLength > 0) && (from > to))
{
return(false);
}
long length = 0;
if ((lengthLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(lengthStartIndex, lengthLength),
out length))
{
return(false);
}
// 'from' and 'to' must be less than 'length'
if ((toLength > 0) && (lengthLength > 0) && (to >= length))
{
return(false);
}
var result = new ContentRangeHeaderValue();
result._unit = unit;
if (fromLength > 0)
{
result._from = from;
result._to = to;
}
if (lengthLength > 0)
{
result._length = length;
}
parsedValue = result;
return(true);
}
public static bool TryParse(string input, out ContentRangeHeaderValue parsedValue)
{
var index = 0;
return(Parser.TryParseValue(input, ref index, out parsedValue));
}
private static bool TryCreateContentRange(
string input,
string unit,
int fromStartIndex,
int fromLength,
int toStartIndex,
int toLength,
int lengthStartIndex,
int lengthLength,
out ContentRangeHeaderValue parsedValue)
{
parsedValue = null;
long from = 0;
if ((fromLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(fromStartIndex, fromLength), out from))
{
return false;
}
long to = 0;
if ((toLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(toStartIndex, toLength), out to))
{
return false;
}
// 'from' must not be greater than 'to'
if ((fromLength > 0) && (toLength > 0) && (from > to))
{
return false;
}
long length = 0;
if ((lengthLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(lengthStartIndex, lengthLength),
out length))
{
return false;
}
// 'from' and 'to' must be less than 'length'
if ((toLength > 0) && (lengthLength > 0) && (to >= length))
{
return false;
}
var result = new ContentRangeHeaderValue();
result._unit = unit;
if (fromLength > 0)
{
result._from = from;
result._to = to;
}
if (lengthLength > 0)
{
result._length = length;
}
parsedValue = result;
return true;
}
private static int GetContentRangeLength(string input, int startIndex, out ContentRangeHeaderValue parsedValue)
{
Contract.Requires(startIndex >= 0);
parsedValue = null;
if (string.IsNullOrEmpty(input) || (startIndex >= input.Length))
{
return 0;
}
// Parse the unit string: <unit> in '<unit> <from>-<to>/<length>'
var unitLength = HttpRuleParser.GetTokenLength(input, startIndex);
if (unitLength == 0)
{
return 0;
}
var unit = input.Substring(startIndex, unitLength);
var current = startIndex + unitLength;
var separatorLength = HttpRuleParser.GetWhitespaceLength(input, current);
if (separatorLength == 0)
{
return 0;
}
current = current + separatorLength;
if (current == input.Length)
{
return 0;
}
// Read range values <from> and <to> in '<unit> <from>-<to>/<length>'
var fromStartIndex = current;
var fromLength = 0;
var toStartIndex = 0;
var toLength = 0;
if (!TryGetRangeLength(input, ref current, out fromLength, out toStartIndex, out toLength))
{
return 0;
}
// After the range is read we expect the length separator '/'
if ((current == input.Length) || (input[current] != '/'))
{
return 0;
}
current++; // Skip '/' separator
current = current + HttpRuleParser.GetWhitespaceLength(input, current);
if (current == input.Length)
{
return 0;
}
// We may not have a length (e.g. 'bytes 1-2/*'). But if we do, parse the length now.
var lengthStartIndex = current;
var lengthLength = 0;
if (!TryGetLengthLength(input, ref current, out lengthLength))
{
return 0;
}
if (!TryCreateContentRange(input, unit, fromStartIndex, fromLength, toStartIndex, toLength,
lengthStartIndex, lengthLength, out parsedValue))
{
return 0;
}
return current - startIndex;
}
private void CheckValidTryParse(string?input, ContentRangeHeaderValue expectedResult)
{
Assert.True(ContentRangeHeaderValue.TryParse(input, out var result));
Assert.Equal(expectedResult, result);
}
private void CheckValidParse(string input, ContentRangeHeaderValue expectedResult)
{
var result = ContentRangeHeaderValue.Parse(input);
Assert.Equal(expectedResult, result);
}
private static bool TryCreateContentRange(
StringSegment input,
StringSegment unit,
int fromStartIndex,
int fromLength,
int toStartIndex,
int toLength,
int lengthStartIndex,
int lengthLength,
[NotNullWhen(true)] out ContentRangeHeaderValue?parsedValue)
{
parsedValue = null;
long from = 0;
if ((fromLength > 0) && !HeaderUtilities.TryParseNonNegativeInt64(input.Subsegment(fromStartIndex, fromLength), out from))
{
return(false);
}
long to = 0;
if ((toLength > 0) && !HeaderUtilities.TryParseNonNegativeInt64(input.Subsegment(toStartIndex, toLength), out to))
{
return(false);
}
// 'from' must not be greater than 'to'
if ((fromLength > 0) && (toLength > 0) && (from > to))
{
return(false);
}
long length = 0;
if ((lengthLength > 0) && !HeaderUtilities.TryParseNonNegativeInt64(input.Subsegment(lengthStartIndex, lengthLength),
out length))
{
return(false);
}
// 'from' and 'to' must be less than 'length'
if ((toLength > 0) && (lengthLength > 0) && (to >= length))
{
return(false);
}
var result = new ContentRangeHeaderValue();
result._unit = unit;
if (fromLength > 0)
{
result.From = from;
result.To = to;
}
if (lengthLength > 0)
{
result.Length = length;
}
parsedValue = result;
return(true);
}
private void CheckValidTryParse(string input, ContentRangeHeaderValue expectedResult)
{
ContentRangeHeaderValue result = null;
Assert.True(ContentRangeHeaderValue.TryParse(input, out result));
Assert.Equal(expectedResult, result);
}
