protected override Task <bool> ReadAsynchronously()
        {
            switch (this.State)
            {
            case ODataCollectionReaderState.Start:
                return(this.ReadAtStartImplementationAsync());

            case ODataCollectionReaderState.CollectionStart:
                return(this.ReadAtCollectionStartImplementationAsync());

            case ODataCollectionReaderState.Value:
                return(this.ReadAtValueImplementationAsync());

            case ODataCollectionReaderState.CollectionEnd:
                return(this.ReadAtCollectionEndImplementationAsync());

            case ODataCollectionReaderState.Exception:        // fall through
            case ODataCollectionReaderState.Completed:
                Debug.Assert(false, "This case should have been caught earlier.");
                return(TaskUtils.GetFaultedTask <bool>(new ODataException(Strings.General_InternalError(InternalErrorCodes.ODataCollectionReaderCoreAsync_ReadAsynchronously))));

            default:
                Debug.Assert(false, "Unsupported collection reader state " + this.State + " detected.");
                return(TaskUtils.GetFaultedTask <bool>(new ODataException(Strings.General_InternalError(InternalErrorCodes.ODataCollectionReaderCoreAsync_ReadAsynchronously))));
            }
        }
Esempio n. 2
0
        protected override Task <bool> ReadAsynchronously()
        {
            Task <bool> result;

            switch (this.State)
            {
            case ODataReaderState.Start:
                result = this.ReadAtStartImplementationAsync();
                break;

            case ODataReaderState.FeedStart:
                result = this.ReadAtFeedStartImplementationAsync();
                break;

            case ODataReaderState.FeedEnd:
                result = this.ReadAtFeedEndImplementationAsync();
                break;

            case ODataReaderState.EntryStart:
                result = TaskUtils.GetTaskForSynchronousOperation(() => this.IncreaseEntryDepth())
                         .FollowOnSuccessWithTask(t => this.ReadAtEntryStartImplementationAsync());
                break;

            case ODataReaderState.EntryEnd:
                result = TaskUtils.GetTaskForSynchronousOperation(() => this.DecreaseEntryDepth())
                         .FollowOnSuccessWithTask(t => this.ReadAtEntryEndImplementationAsync());
                break;

            case ODataReaderState.NavigationLinkStart:
                result = this.ReadAtNavigationLinkStartImplementationAsync();
                break;

            case ODataReaderState.NavigationLinkEnd:
                result = this.ReadAtNavigationLinkEndImplementationAsync();
                break;

            case ODataReaderState.EntityReferenceLink:
                result = this.ReadAtEntityReferenceLinkAsync();
                break;

            case ODataReaderState.Exception:        // fall through
            case ODataReaderState.Completed:
                result = TaskUtils.GetFaultedTask <bool>(new ODataException(Strings.ODataReaderCore_NoReadCallsAllowed(this.State)));
                break;

            default:
                Debug.Assert(false, "Unsupported reader state " + this.State + " detected.");
                result = TaskUtils.GetFaultedTask <bool>(new ODataException(Strings.General_InternalError(InternalErrorCodes.ODataReaderCoreAsync_ReadAsynchronously)));
                break;
            }

            return(result.FollowOnSuccessWith(t =>
            {
                if ((this.State == ODataReaderState.EntryStart || this.State == ODataReaderState.EntryEnd) && this.Item != null)
                {
                    ReaderValidationUtils.ValidateEntry(this.CurrentEntry);
                }

                return t.Result;
            }));
        }