Depending on the concrete type of the stream managed by a NetFxToWinRtStreamAdapter, we want the ReadAsync / WriteAsync / FlushAsync / etc. operation to be implemented differently. This is for best performance as we can take advantage of the specifics of particular stream types. For instance, ReadAsync currently has a special implementation for memory streams. Moreover, knowledge about the actual runtime type of the IBuffer can also help chosing the optimal implementation. This type provides static methods that encapsulate the performance logic and can be used by NetFxToWinRtStreamAdapter.
コード例 #1
0
        public IAsyncOperation <Boolean> FlushAsync()
        {
            Contract.Ensures(Contract.Result <IAsyncOperation <Boolean> >() != null);
            Contract.EndContractBlock();

            Stream str = EnsureNotDisposed();

            return(StreamOperationsImplementation.FlushAsync_AbstractStream(str));
        }
コード例 #2
0
        public IAsyncOperationWithProgress <IBuffer, uint> ReadAsync(IBuffer buffer, uint count, InputStreamOptions options)
        {
            if (buffer == null)
            {
                // Mapped to E_POINTER.
                throw new ArgumentNullException(nameof(buffer));
            }

            if (count < 0 || int.MaxValue < count)
            {
                ArgumentOutOfRangeException ex = new ArgumentOutOfRangeException(nameof(count));
                ex.HResult = __HResults.E_INVALIDARG;
                throw ex;
            }

            if (buffer.Capacity < count)
            {
                ArgumentException ex = new ArgumentException(SR.Argument_InsufficientBufferCapacity);
                ex.HResult = __HResults.E_INVALIDARG;
                throw ex;
            }

            if (!(options == InputStreamOptions.None || options == InputStreamOptions.Partial || options == InputStreamOptions.ReadAhead))
            {
                ArgumentOutOfRangeException ex = new ArgumentOutOfRangeException(nameof(options),
                                                                                 SR.ArgumentOutOfRange_InvalidInputStreamOptionsEnumValue);
                ex.HResult = __HResults.E_INVALIDARG;
                throw ex;
            }

            Stream str = EnsureNotDisposed();

            IAsyncOperationWithProgress <IBuffer, uint> readAsyncOperation;

            switch (_readOptimization)
            {
            case StreamReadOperationOptimization.MemoryStream:
                readAsyncOperation = StreamOperationsImplementation.ReadAsync_MemoryStream(str, buffer, count);
                break;

            case StreamReadOperationOptimization.AbstractStream:
                readAsyncOperation = StreamOperationsImplementation.ReadAsync_AbstractStream(str, buffer, count, options);
                break;

            // Use this pattern to add more optimisation options if necessary:
            //case StreamReadOperationOptimization.XxxxStream:
            //    readAsyncOperation = StreamOperationsImplementation.ReadAsync_XxxxStream(str, buffer, count, options);
            //    break;

            default:
                Debug.Fail("We should never get here. Someone forgot to handle an input stream optimisation option.");
                readAsyncOperation = null;
                break;
            }

            return(readAsyncOperation);
        }
コード例 #3
0
        public IAsyncOperationWithProgress<uint, uint> WriteAsync(IBuffer buffer)
        {
            if (buffer == null)
            {
                // Mapped to E_POINTER.
                throw new ArgumentNullException(nameof(buffer));
            }

            if (buffer.Capacity < buffer.Length)
            {
                ArgumentException ex = new ArgumentException(global::Windows.Storage.Streams.SR.Argument_BufferLengthExceedsCapacity);
                ex.SetHResult(E_INVALIDARG);
                throw ex;
            }

            Stream str = EnsureNotDisposed();
            return StreamOperationsImplementation.WriteAsync_AbstractStream(str, buffer);
        }
コード例 #4
0
        public IAsyncOperationWithProgress <UInt32, UInt32> WriteAsync(IBuffer buffer)
        {
            if (buffer == null)
            {
                // Mapped to E_POINTER.
                throw new ArgumentNullException("buffer");
            }

            if (buffer.Capacity < buffer.Length)
            {
                ArgumentException ex = new ArgumentException(SR.Argument_BufferLengthExceedsCapacity);
                ex.SetErrorCode(HResults.E_INVALIDARG);
                throw ex;
            }

            // Commented due to a reported CCRewrite bug. Should uncomment when fixed:
            //Contract.Ensures(Contract.Result<IAsyncOperationWithProgress<UInt32, UInt32>>() != null);
            //Contract.EndContractBlock();

            Stream str = EnsureNotDisposed();

            return(StreamOperationsImplementation.WriteAsync_AbstractStream(str, buffer));
        }
コード例 #5
0
        public IAsyncOperationWithProgress <IBuffer, UInt32> ReadAsync(IBuffer buffer, UInt32 count, InputStreamOptions options)
        {
            if (buffer == null)
            {
                // Mapped to E_POINTER.
                throw new ArgumentNullException("buffer");
            }

            if (count < 0 || Int32.MaxValue < count)
            {
                ArgumentOutOfRangeException ex = new ArgumentOutOfRangeException("count");
                ex.SetErrorCode(HResults.E_INVALIDARG);
                throw ex;
            }

            if (buffer.Capacity < count)
            {
                ArgumentException ex = new ArgumentException(SR.Argument_InsufficientBufferCapacity);
                ex.SetErrorCode(HResults.E_INVALIDARG);
                throw ex;
            }

            if (!(options == InputStreamOptions.None || options == InputStreamOptions.Partial || options == InputStreamOptions.ReadAhead))
            {
                ArgumentOutOfRangeException ex = new ArgumentOutOfRangeException("options",
                                                                                 SR.ArgumentOutOfRange_InvalidInputStreamOptionsEnumValue);
                ex.SetErrorCode(HResults.E_INVALIDARG);
                throw ex;
            }

            // Commented due to a reported CCRewrite bug. Should uncomment when fixed:
            //Contract.Ensures(Contract.Result<IAsyncOperationWithProgress<IBuffer, UInt32>>() != null);
            //Contract.EndContractBlock();

            Stream str = EnsureNotDisposed();

            IAsyncOperationWithProgress <IBuffer, UInt32> readAsyncOperation;

            switch (_readOptimization)
            {
            case StreamReadOperationOptimization.MemoryStream:
                readAsyncOperation = StreamOperationsImplementation.ReadAsync_MemoryStream(str, buffer, count);
                break;

            case StreamReadOperationOptimization.AbstractStream:
                readAsyncOperation = StreamOperationsImplementation.ReadAsync_AbstractStream(str, buffer, count, options);
                break;

            // Use this pattern to add more optimisation options if necessary:
            //case StreamReadOperationOptimization.XxxxStream:
            //    readAsyncOperation = StreamOperationsImplementation.ReadAsync_XxxxStream(str, buffer, count, options);
            //    break;

            default:
                Debug.Assert(false, "We should never get here. Someone forgot to handle an input stream optimisation option.");
                readAsyncOperation = null;
                break;
            }

            return(readAsyncOperation);
        }
コード例 #6
0
        public IAsyncOperation <bool> FlushAsync()
        {
            Stream str = EnsureNotDisposed();

            return(StreamOperationsImplementation.FlushAsync_AbstractStream(str));
        }