Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

344 lines
12 KiB
C#

using System;
using System.Data.Common;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
namespace System.Data.SqlClient
{
sealed internal class SqlSequentialStream : System.IO.Stream
{
private SqlDataReader _reader; // The SqlDataReader that we are reading data from
private int _columnIndex; // The index of out column in the table
private Task _currentTask; // Holds the current task being processed
private int _readTimeout; // Read timeout for this stream in ms (for Stream.ReadTimeout)
private CancellationTokenSource _disposalTokenSource; // Used to indicate that a cancellation is requested due to disposal
internal SqlSequentialStream(SqlDataReader reader, int columnIndex)
{
Debug.Assert(reader != null, "Null reader when creating sequential stream");
Debug.Assert(columnIndex >= 0, "Invalid column index when creating sequential stream");
_reader = reader;
_columnIndex = columnIndex;
_currentTask = null;
_disposalTokenSource = new CancellationTokenSource();
// Safely safely convert the CommandTimeout from seconds to milliseconds
if ((reader.Command != null) && (reader.Command.CommandTimeout != 0))
{
_readTimeout = (int)Math.Min((long)reader.Command.CommandTimeout * 1000L, (long)Int32.MaxValue);
}
else
{
_readTimeout = Timeout.Infinite;
}
}
public override bool CanRead
{
get { return ((_reader != null) && (!_reader.IsClosed)); }
}
public override bool CanSeek
{
get { return false; }
}
public override bool CanTimeout
{
get { return true; }
}
public override bool CanWrite
{
get { return false; }
}
public override void Flush()
{ }
public override long Length
{
get { throw ADP.NotSupported(); }
}
public override long Position
{
get { throw ADP.NotSupported(); }
set { throw ADP.NotSupported(); }
}
public override int ReadTimeout
{
get { return _readTimeout; }
set
{
if ((value > 0) || (value == Timeout.Infinite))
{
_readTimeout = value;
}
else
{
throw ADP.ArgumentOutOfRange("value");
}
}
}
internal int ColumnIndex
{
get { return _columnIndex; }
}
public override int Read(byte[] buffer, int offset, int count)
{
ValidateReadParameters(buffer, offset, count);
if (!CanRead)
{
throw ADP.ObjectDisposed(this);
}
if (_currentTask != null)
{
throw ADP.AsyncOperationPending();
}
try
{
return _reader.GetBytesInternalSequential(_columnIndex, buffer, offset, count, _readTimeout);
}
catch (SqlException ex)
{
// Stream.Read() can't throw a SqlException - so wrap it in an IOException
throw ADP.ErrorReadingFromStream(ex);
}
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (!CanRead)
{
// This is checked in ReadAsync - but its a better for the user if it throw here instead of having to wait for EndRead
throw ADP.ObjectDisposed(this);
}
Task readTask = ReadAsync(buffer, offset, count, CancellationToken.None);
if (callback != null)
{
readTask.ContinueWith((t) => callback(t), TaskScheduler.Default);
}
return readTask;
}
public override int EndRead(IAsyncResult asyncResult)
{
if (asyncResult == null)
{
throw ADP.ArgumentNull("asyncResult");
}
// Wait for the task to complete - this will also cause any exceptions to be thrown
Task<int> readTask = (Task<int>)asyncResult;
try
{
readTask.Wait();
}
catch (AggregateException ex)
{
throw ex.InnerException;
}
return readTask.Result;
}
public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
ValidateReadParameters(buffer, offset, count);
TaskCompletionSource<int> completion = new TaskCompletionSource<int>();
if (!CanRead)
{
completion.SetException(ADP.ExceptionWithStackTrace(ADP.ObjectDisposed(this)));
}
else
{
try
{
Task original = Interlocked.CompareExchange<Task>(ref _currentTask, completion.Task, null);
if (original != null)
{
completion.SetException(ADP.ExceptionWithStackTrace(ADP.AsyncOperationPending()));
}
else
{
// Set up a combined cancellation token for both the user's and our disposal tokens
CancellationTokenSource combinedTokenSource;
if (!cancellationToken.CanBeCanceled)
{
// Users token is not cancellable - just use ours
combinedTokenSource = _disposalTokenSource;
}
else
{
// Setup registrations from user and disposal token to cancel the combined token
combinedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _disposalTokenSource.Token);
}
int bytesRead = 0;
Task<int> getBytesTask = null;
var reader = _reader;
if ((reader != null) && (!cancellationToken.IsCancellationRequested) && (!_disposalTokenSource.Token.IsCancellationRequested))
{
getBytesTask = reader.GetBytesAsync(_columnIndex, buffer, offset, count, _readTimeout, combinedTokenSource.Token, out bytesRead);
}
if (getBytesTask == null)
{
_currentTask = null;
if (cancellationToken.IsCancellationRequested)
{
completion.SetCanceled();
}
else if (!CanRead)
{
completion.SetException(ADP.ExceptionWithStackTrace(ADP.ObjectDisposed(this)));
}
else
{
completion.SetResult(bytesRead);
}
if (combinedTokenSource != _disposalTokenSource)
{
combinedTokenSource.Dispose();
}
}
else
{
getBytesTask.ContinueWith((t) =>
{
_currentTask = null;
// If we completed, but _reader is null (i.e. the stream is closed), then report cancellation
if ((t.Status == TaskStatus.RanToCompletion) && (CanRead))
{
completion.SetResult((int)t.Result);
}
else if (t.Status == TaskStatus.Faulted)
{
if (t.Exception.InnerException is SqlException)
{
// Stream.ReadAsync() can't throw a SqlException - so wrap it in an IOException
completion.SetException(ADP.ExceptionWithStackTrace(ADP.ErrorReadingFromStream(t.Exception.InnerException)));
}
else
{
completion.SetException(t.Exception.InnerException);
}
}
else if (!CanRead)
{
completion.SetException(ADP.ExceptionWithStackTrace(ADP.ObjectDisposed(this)));
}
else
{
completion.SetCanceled();
}
if (combinedTokenSource != _disposalTokenSource)
{
combinedTokenSource.Dispose();
}
}, TaskScheduler.Default);
}
}
}
catch (Exception ex)
{
// In case of any errors, ensure that the completion is completed and the task is set back to null if we switched it
completion.TrySetException(ex);
Interlocked.CompareExchange(ref _currentTask, null, completion.Task);
throw;
}
}
return completion.Task;
}
public override long Seek(long offset, IO.SeekOrigin origin)
{
throw ADP.NotSupported();
}
public override void SetLength(long value)
{
throw ADP.NotSupported();
}
public override void Write(byte[] buffer, int offset, int count)
{
throw ADP.NotSupported();
}
/// <summary>
/// Forces the stream to act as if it was closed (i.e. CanRead=false and Read() throws)
/// This does not actually close the stream, read off the rest of the data or dispose this
/// </summary>
internal void SetClosed()
{
_disposalTokenSource.Cancel();
_reader = null;
// Wait for pending task
var currentTask = _currentTask;
if (currentTask != null)
{
((IAsyncResult)currentTask).AsyncWaitHandle.WaitOne();
}
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
// Set the stream as closed
SetClosed();
}
base.Dispose(disposing);
}
/// <summary>
/// Checks the the parameters passed into a Read() method are valid
/// </summary>
/// <param name="buffer"></param>
/// <param name="index"></param>
/// <param name="count"></param>
internal static void ValidateReadParameters(byte[] buffer, int offset, int count)
{
if (buffer == null)
{
throw ADP.ArgumentNull(ADP.ParameterBuffer);
}
if (offset < 0)
{
throw ADP.ArgumentOutOfRange(ADP.ParameterOffset);
}
if (count < 0)
{
throw ADP.ArgumentOutOfRange(ADP.ParameterCount);
}
try
{
if (checked(offset + count) > buffer.Length)
{
throw ExceptionBuilder.InvalidOffsetLength();
}
}
catch (OverflowException)
{
// If we've overflowed when adding offset and count, then they never would have fit into buffer anyway
throw ExceptionBuilder.InvalidOffsetLength();
}
}
}
}