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); }