public override Task WriteAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer", ResourceHelper.GetResourceString("ArgumentNull_Buffer"));
}
if (offset < 0)
{
throw new ArgumentOutOfRangeException("offset", ResourceHelper.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
}
if (count < 0)
{
throw new ArgumentOutOfRangeException("count", ResourceHelper.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
}
if (buffer.Length - offset < count)
{
throw new ArgumentException(ResourceHelper.GetResourceString("Argument_InvalidOffLen"));
}
Contract.EndContractBlock(); // contract validation copied from Write(...)
// If cancellation is already requested, bail early
if (cancellationToken.IsCancellationRequested)
{
return(Task.FromCancellation(cancellationToken));
}
try
{
Write(buffer, offset, count);
return(Task.CompletedTask);
}
catch (OperationCanceledException oce)
{
return(Task.FromCancellation <VoidTaskResult>(oce));
}
catch (Exception exception)
{
return(Task.FromException(exception));
}
}
// returns a bool saying whether we allocated a new array.
private bool EnsureCapacity(int value)
{
// Check for overflow
if (value < 0)
{
throw new IOException(ResourceHelper.GetResourceString("IO.IO_StreamTooLong"));
}
if (value > _capacity)
{
int newCapacity = value;
if (newCapacity < 256)
{
newCapacity = 256;
}
if (newCapacity < _capacity * 2)
{
newCapacity = _capacity * 2;
}
Capacity = newCapacity;
return(true);
}
return(false);
}
public static int GetPrime(int min)
{
if (min < 0)
{
throw new ArgumentException(ResourceHelper.GetResourceString("Arg_HTCapacityOverflow"));
}
for (int i = 0; i < HashHelpers.primes.Length; i++)
{
int num = HashHelpers.primes[i];
if (num >= min)
{
return(num);
}
}
for (int j = min | 1; j < 2147483647; j += 2)
{
if (HashHelpers.IsPrime(j) && (j - 1) % 101 != 0)
{
return(j);
}
}
return(min);
}
internal static void ThrowArgumentOutOfRangeException()
{
throw new ArgumentOutOfRangeException(ThrowHelper.GetArgumentName(ExceptionArgument.index), ResourceHelper.GetResourceString(ThrowHelper.GetResourceName(ExceptionResource.ArgumentOutOfRange_Index)));
}
internal static void ThrowObjectDisposedException(string objectName, ExceptionResource resource)
{
throw new ObjectDisposedException(objectName, ResourceHelper.GetResourceString(ThrowHelper.GetResourceName(resource)));
}
internal static void ThrowUnauthorizedAccessException(ExceptionResource resource)
{
throw new UnauthorizedAccessException(ResourceHelper.GetResourceString(ThrowHelper.GetResourceName(resource)));
}
internal static void ThrowNotSupportedException(ExceptionResource resource)
{
throw new NotSupportedException(ResourceHelper.GetResourceString(ThrowHelper.GetResourceName(resource)));
}
public static void StreamIsClosed()
{
throw new ObjectDisposedException(null, ResourceHelper.GetResourceString("ObjectDisposed_StreamClosed"));
}
internal static void ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
{
throw new ArgumentOutOfRangeException(ThrowHelper.GetArgumentName(argument), ResourceHelper.GetResourceString(ThrowHelper.GetResourceName(resource)));
}
internal static void ThrowArgumentException(ExceptionResource resource, ExceptionArgument argument)
{
throw new ArgumentException(ResourceHelper.GetResourceString(ThrowHelper.GetResourceName(resource)), ThrowHelper.GetArgumentName(argument));
}
internal static void ThrowWrongValueTypeArgumentException(object value, Type targetType)
{
throw new ArgumentException(ResourceHelper.GetResourceString("Arg_WrongType"));
}
internal static void ReadNotSupported()
{
throw new NotSupportedException(ResourceHelper.GetResourceString("NotSupported_UnreadableStream"));
}
public static void WriteNotSupported()
{
throw new NotSupportedException(ResourceHelper.GetResourceString("NotSupported_UnwritableStream"));
}
public static void MemoryStreamNotExpandable()
{
throw new NotSupportedException(ResourceHelper.GetResourceString("NotSupported_MemStreamNotExpandable"));
}
public override Task CopyToAsync(Stream destination, Int32 bufferSize, CancellationToken cancellationToken)
{
// This implementation offers beter performance compared to the base class version.
// The parameter checks must be in [....] with the base version:
if (destination == null)
{
throw new ArgumentNullException("destination");
}
if (bufferSize <= 0)
{
throw new ArgumentOutOfRangeException("bufferSize", ResourceHelper.GetResourceString("ArgumentOutOfRange_NeedPosNum"));
}
if (!CanRead && !CanWrite)
{
throw new ObjectDisposedException(null, ResourceHelper.GetResourceString("ObjectDisposed_StreamClosed"));
}
if (!destination.CanRead && !destination.CanWrite)
{
throw new ObjectDisposedException("destination", ResourceHelper.GetResourceString("ObjectDisposed_StreamClosed"));
}
if (!CanRead)
{
throw new NotSupportedException(ResourceHelper.GetResourceString("NotSupported_UnreadableStream"));
}
if (!destination.CanWrite)
{
throw new NotSupportedException(ResourceHelper.GetResourceString("NotSupported_UnwritableStream"));
}
Contract.EndContractBlock();
// If we have been inherited into a subclass, the following implementation could be incorrect
// since it does not call through to Read() or Write() which a subclass might have overriden.
// To be safe we will only use this implementation in cases where we know it is safe to do so,
// and delegate to our base class (which will call into Read/Write) when we are not sure.
if (this.GetType() != typeof(MemoryStream))
{
return(base.CopyToAsync(destination, bufferSize, cancellationToken));
}
// If cancelled - return fast:
if (cancellationToken.IsCancellationRequested)
{
return(Task.FromCancellation(cancellationToken));
}
// Avoid copying data from this buffer into a temp buffer:
// (require that InternalEmulateRead does not throw,
// otherwise it needs to be wrapped into try-catch-Task.FromException like memStrDest.Write below)
Int32 pos = _position;
Int32 n = InternalEmulateRead(_length - _position);
// If destination is not a memory stream, write there asynchronously:
MemoryStream memStrDest = destination as MemoryStream;
if (memStrDest == null)
{
return(destination.WriteAsync(_buffer, pos, n, cancellationToken));
}
try {
// If destination is a MemoryStream, CopyTo synchronously:
memStrDest.Write(_buffer, pos, n);
return(Task.CompletedTask);
} catch (Exception ex) {
return(Task.FromException(ex));
}
}
internal static void ThrowInvalidOperationException(ExceptionResource resource)
{
throw new InvalidOperationException(ResourceHelper.GetResourceString(ThrowHelper.GetResourceName(resource)));
}
//Changelog: Used ClusteredArray's internal CopyFrom method.
public override void Write(byte[] buffer, int offset, int count)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer", ResourceHelper.GetResourceString("ArgumentNull_Buffer"));
}
if (offset < 0)
{
throw new ArgumentOutOfRangeException("offset", ResourceHelper.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
}
if (count < 0)
{
throw new ArgumentOutOfRangeException("count", ResourceHelper.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
}
if (buffer.Length - offset < count)
{
throw new ArgumentException(ResourceHelper.GetResourceString("Argument_InvalidOffLen"));
}
#if DEBUG
Contract.EndContractBlock();
#endif
if (!_isOpen)
{
__Error.StreamIsClosed();
}
EnsureWriteable();
int i = _position + count;
// Check for overflow
if (i < 0)
{
throw new IOException(ResourceHelper.GetResourceString("IO.IO_StreamTooLong"));
}
if (i > _length)
{
bool mustZero = _position > _length;
if (i > _capacity)
{
bool allocatedNewArray = EnsureCapacity(i);
if (allocatedNewArray)
{
mustZero = false;
}
}
if (mustZero)
{
ClusteredArray <byte> .Clear(_buffer, _length, i - _length);
}
_length = i;
}
if (count <= 8)
{
int byteCount = count;
while (--byteCount >= 0)
{
_buffer[_position + byteCount] = buffer[offset + byteCount];
}
}
else
{
_buffer.CopyFrom(buffer, offset, _position, count);
}
_position = i;
}
internal static void ThrowSecurityException(ExceptionResource resource)
{
throw new SecurityException(ResourceHelper.GetResourceString(ThrowHelper.GetResourceName(resource)));
}
private static void ParseFrameworkName(string frameworkName, out string identifier, out int version, out string profile)
{
if (frameworkName == null)
{
throw new ArgumentNullException("frameworkName");
}
if (frameworkName.Length == 0)
{
throw new ArgumentException(ResourceHelper
.GetResourceString("Argument_StringZeroLength"), "frameworkName");
}
string[] array = frameworkName.Split(new char[]
{
','
});
version = 0;
if (array.Length < 2 || array.Length > 3)
{
throw new ArgumentException(ResourceHelper.GetResourceString("Argument_FrameworkNameTooShort"), "frameworkName");
}
identifier = array[0].Trim();
if (identifier.Length == 0)
{
throw new ArgumentException(ResourceHelper.GetResourceString("Argument_FrameworkNameInvalid"), "frameworkName");
}
bool flag = false;
profile = null;
for (int i = 1; i < array.Length; i++)
{
string[] array2 = array[i].Split(new char[]
{
'='
});
if (array2.Length != 2)
{
throw new ArgumentException(ResourceHelper.GetResourceString("SR.Argument_FrameworkNameInvalid"), "frameworkName");
}
string text = array2[0].Trim();
string text2 = array2[1].Trim();
if (text.Equals("Version", StringComparison.OrdinalIgnoreCase))
{
flag = true;
if (text2.Length > 0 && (text2[0] == 'v' || text2[0] == 'V'))
{
text2 = text2.Substring(1);
}
Version version2 = new Version(text2);
version = version2.Major * 10000;
if (version2.Minor > 0)
{
version += version2.Minor * 100;
}
if (version2.Build > 0)
{
version += version2.Build;
}
}
else
{
if (!text.Equals("Profile", StringComparison.OrdinalIgnoreCase))
{
throw new ArgumentException(ResourceHelper.GetResourceString("Argument_FrameworkNameInvalid"), "frameworkName");
}
if (!string.IsNullOrEmpty(text2))
{
profile = text2;
}
}
}
if (!flag)
{
throw new ArgumentException(ResourceHelper.GetResourceString("Argument_FrameworkNameMissingVersion"), "frameworkName");
}
}
public static void EndOfFile()
{
throw new EndOfStreamException(ResourceHelper.GetResourceString("IO.EOF_ReadBeyondEOF"));
}
