private object GetNestedObjectValue(object result) { if (result != DBNull.Value) { RecordState newSource = result as RecordState; if (newSource != null) { if (newSource.IsNull) { result = (object)DBNull.Value; } else { BridgeDataRecord bridgeDataRecord = new BridgeDataRecord(this._shaper, this.Depth + 1); bridgeDataRecord.SetRecordSource(newSource, true); result = (object)bridgeDataRecord; this._currentNestedRecord = bridgeDataRecord; this._currentNestedReader = (BridgeDataReader)null; } } else { Coordinator <RecordState> coordinator = result as Coordinator <RecordState>; if (coordinator != null) { BridgeDataReader bridgeDataReader = new BridgeDataReader(this._shaper, coordinator.TypedCoordinatorFactory, this.Depth + 1, (IEnumerator <KeyValuePair <Shaper <RecordState>, CoordinatorFactory <RecordState> > >)null); result = (object)bridgeDataReader; this._currentNestedRecord = (BridgeDataRecord)null; this._currentNestedReader = bridgeDataReader; } } } return(result); }
private void SetShaper(Shaper <RecordState> shaper, CoordinatorFactory <RecordState> coordinatorFactory, int depth) { _shaper = shaper; _coordinatorFactory = coordinatorFactory; _dataRecord = new BridgeDataRecord(shaper, depth); if (!_shaper.DataWaiting) { _shaper.DataWaiting = _shaper.RootEnumerator.MoveNext(); } InitializeHasRows(); }
private async Task SetShaperAsync( Shaper <RecordState> shaper, CoordinatorFactory <RecordState> coordinatorFactory, int depth, CancellationToken cancellationToken) { this._shaper = shaper; this._coordinatorFactory = coordinatorFactory; this._dataRecord = new BridgeDataRecord(shaper, depth); if (!this._shaper.DataWaiting) { this._shaper.DataWaiting = (await this._shaper.RootEnumerator.MoveNextAsync(cancellationToken).WithCurrentCulture <bool>() ? 1 : 0) != 0; } this.InitializeHasRows(); }
private async Task SetShaperAsync( Shaper <RecordState> shaper, CoordinatorFactory <RecordState> coordinatorFactory, int depth, CancellationToken cancellationToken) { _shaper = shaper; _coordinatorFactory = coordinatorFactory; _dataRecord = new BridgeDataRecord(shaper, depth); if (!_shaper.DataWaiting) { _shaper.DataWaiting = await _shaper.RootEnumerator.MoveNextAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false); } InitializeHasRows(); }
private async Task SetShaperAsync( Shaper <RecordState> shaper, CoordinatorFactory <RecordState> coordinatorFactory, int depth, CancellationToken cancellationToken) { _shaper = shaper; _coordinatorFactory = coordinatorFactory; _dataRecord = new BridgeDataRecord(shaper, depth); if (!_shaper.DataWaiting) { _shaper.DataWaiting = await _shaper.RootEnumerator.MoveNextAsync(cancellationToken).WithCurrentCulture(); } InitializeHasRows(); }
private async Task CloseNestedObjectImplicitlyAsync(CancellationToken cancellationToken) { BridgeDataRecord currentNestedRecord = this._currentNestedRecord; if (currentNestedRecord != null) { this._currentNestedRecord = (BridgeDataRecord)null; await currentNestedRecord.CloseImplicitlyAsync(cancellationToken).WithCurrentCulture(); } BridgeDataReader currentNestedReader = this._currentNestedReader; if (currentNestedReader == null) { return; } this._currentNestedReader = (BridgeDataReader)null; await currentNestedReader.CloseImplicitlyAsync(cancellationToken).WithCurrentCulture(); }
private object CloseNestedObjectImplicitly() { BridgeDataRecord currentNestedRecord = this._currentNestedRecord; if (currentNestedRecord != null) { this._currentNestedRecord = (BridgeDataRecord)null; currentNestedRecord.CloseImplicitly(); } BridgeDataReader currentNestedReader = this._currentNestedReader; if (currentNestedReader != null) { this._currentNestedReader = (BridgeDataReader)null; currentNestedReader.CloseImplicitly(); } return((object)null); }
/// <summary> /// An asynchronous version of <see cref="CloseNestedObjectImplicitly" />, which /// Ensure that whatever column we're currently processing is implicitly closed; /// </summary> private async Task CloseNestedObjectImplicitlyAsync(CancellationToken cancellationToken) { // it would be nice to use Interlocked.Exchange to avoid multi-thread `race condition risk // when the the bridge is being misused by the user accessing it with multiple threads. // but this is called frequently enough to have a performance impact var currentNestedRecord = _currentNestedRecord; if (null != currentNestedRecord) { _currentNestedRecord = null; await currentNestedRecord.CloseImplicitlyAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false); } var currentNestedReader = _currentNestedReader; if (null != currentNestedReader) { _currentNestedReader = null; await currentNestedReader.CloseImplicitlyAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false); } }
/// <summary> /// For nested objects (records/readers) we have a bit more work to do; this /// method extracts it all out from the main GetValue method so it doesn't /// have to be so big. /// </summary> /// <param name="result"> </param> /// <returns> </returns> private object GetNestedObjectValue(object result) { if (result != DBNull.Value) { var recordState = result as RecordState; if (null != recordState) { if (recordState.IsNull) { result = DBNull.Value; } else { var nestedRecord = new BridgeDataRecord(_shaper, Depth + 1); nestedRecord.SetRecordSource(recordState, true); result = nestedRecord; _currentNestedRecord = nestedRecord; _currentNestedReader = null; } } else { var coordinator = result as Coordinator <RecordState>; if (null != coordinator) { var nestedReader = new BridgeDataReader( _shaper, coordinator.TypedCoordinatorFactory, Depth + 1, nextResultShaperInfos: null); result = nestedReader; _currentNestedRecord = null; _currentNestedReader = nestedReader; } else { Debug.Fail("unexpected type of nested object result: " + result.GetType()); } } } return(result); }
/// <summary> /// Ensure that whatever column we're currently processing is implicitly closed; /// </summary> private object CloseNestedObjectImplicitly() { // it would be nice to use Interlocked.Exchange to avoid multi-thread `race condition risk // when the the bridge is being misused by the user accessing it with multiple threads. // but this is called frequently enough to have a performance impact var currentNestedRecord = _currentNestedRecord; if (null != currentNestedRecord) { _currentNestedRecord = null; currentNestedRecord.CloseImplicitly(); } var currentNestedReader = _currentNestedReader; if (null != currentNestedReader) { _currentNestedReader = null; currentNestedReader.CloseImplicitly(); } return(null); }