internal FillErrorEventArgs CreateFillErrorEvent (DataTable dataTable, object[] values, Exception e) { FillErrorEventArgs args = new FillErrorEventArgs (dataTable, values); args.Errors = e; args.Continue = false; return args; }
private void OnFillErrorHandler(Exception e, DataTable dataTable, object[] dataValues) { FillErrorEventArgs fillErrorEvent = new FillErrorEventArgs(dataTable, dataValues); fillErrorEvent.Errors = e; OnFillError(fillErrorEvent); if (!fillErrorEvent.Continue) { if (null != fillErrorEvent.Errors) { throw fillErrorEvent.Errors; } throw e; } }
virtual protected void OnFillError(FillErrorEventArgs value) { // V1.2.3300, DbDataAdapter V1.0.3300 FillErrorEventHandler handler = (FillErrorEventHandler) Events[EventFillError]; if (null != handler) { handler(this, value); } }
private void _dbDataAdapter_FillError(object sender, FillErrorEventArgs e) { base.OnFillError(e); }
internal virtual void OnFillErrorInternal (FillErrorEventArgs value) { #if NET_2_0 OnFillError (value); #endif }
private static DataTable LoadTableFromEnumerable <T>(IEnumerable <T> source, DataTable table, LoadOption?options, FillErrorEventHandler errorHandler) where T : DataRow { if (options.HasValue) { switch (options.Value) { case LoadOption.OverwriteChanges: case LoadOption.PreserveChanges: case LoadOption.Upsert: break; default: throw DataSetUtil.InvalidLoadOption(options.Value); } } using (IEnumerator <T> rows = source.GetEnumerator()) { // need to get first row to create table if (!rows.MoveNext()) { return(table ?? throw DataSetUtil.InvalidOperation(SR.DataSetLinq_EmptyDataRowSource)); } DataRow current; if (table == null) { current = rows.Current; if (current == null) { throw DataSetUtil.InvalidOperation(SR.DataSetLinq_NullDataRow); } table = new DataTable() { Locale = CultureInfo.CurrentCulture }; // We do not copy the same properties that DataView.ToTable does. // If user needs that functionality, use other CopyToDataTable overloads. // The reasoning being, the IEnumerator<DataRow> can be sourced from // different DataTable, so we just use the "Default" instead of resolving the difference. foreach (DataColumn column in current.Table.Columns) { table.Columns.Add(column.ColumnName, column.DataType); } } table.BeginLoadData(); try { do { current = rows.Current; if (current == null) { continue; } object[] values = null; try { // 'recoverable' error block switch (current.RowState) { case DataRowState.Detached: if (!current.HasVersion(DataRowVersion.Proposed)) { throw DataSetUtil.InvalidOperation(SR.DataSetLinq_CannotLoadDetachedRow); } goto case DataRowState.Added; case DataRowState.Unchanged: case DataRowState.Added: case DataRowState.Modified: values = current.ItemArray; if (options.HasValue) { table.LoadDataRow(values, options.Value); } else { table.LoadDataRow(values, fAcceptChanges: true); } break; case DataRowState.Deleted: throw DataSetUtil.InvalidOperation(SR.DataSetLinq_CannotLoadDeletedRow); default: throw DataSetUtil.InvalidDataRowState(current.RowState); } } catch (Exception e) { if (!DataSetUtil.IsCatchableExceptionType(e)) { throw; } FillErrorEventArgs fillError = null; if (null != errorHandler) { fillError = new FillErrorEventArgs(table, values) { Errors = e }; errorHandler.Invoke(rows, fillError); } if (null == fillError) { throw; } else if (!fillError.Continue) { if (ReferenceEquals(fillError.Errors ?? e, e)) { // if user didn't change exception to throw (or set it to null) throw; } else { // user may have changed exception to throw in handler throw fillError.Errors; } } } } while (rows.MoveNext()); } finally { table.EndLoadData(); } } Debug.Assert(null != table, "null DataTable"); return(table); }
/// <summary> /// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed. /// <example> /// fillerroreventhandler.BeginInvoke(sender, e, callback); /// </example> /// </summary> public static IAsyncResult BeginInvoke(this FillErrorEventHandler fillerroreventhandler, Object sender, FillErrorEventArgs e, AsyncCallback callback) { if(fillerroreventhandler == null) throw new ArgumentNullException("fillerroreventhandler"); return fillerroreventhandler.BeginInvoke(sender, e, callback, null); }
internal virtual void OnFillErrorInternal (FillErrorEventArgs value) { OnFillError (value); }
/// <summary>Invoked when an error occurs during a Fill.</summary> /// <param name="value">A <see cref="T:System.Data.FillErrorEventArgs" /> object.</param> protected virtual void OnFillError(FillErrorEventArgs value) { FillErrorEventHandler fillErrorEventHandler = (FillErrorEventHandler)base.Events[NativeDataAdapter.EventFillError]; if (fillErrorEventHandler != null) { fillErrorEventHandler(this, value); } }
private void OnFillErrorHandler(Exception e, DataTable dataTable, object[] dataValues) { FillErrorEventArgs fillErrorEventArgs = new FillErrorEventArgs(dataTable, dataValues); fillErrorEventArgs.Errors = e; this.OnFillError(fillErrorEventArgs); if (fillErrorEventArgs.Continue) { return; } if (fillErrorEventArgs.Errors != null) { throw fillErrorEventArgs.Errors; } throw e; }
private void ExecuteSqlFillErrorHandler(object sender, FillErrorEventArgs e) { log.Error("ExecuteSqlFillErrorHandler", e.Errors); // Setting e.Continue to True tells the Load method to continue trying. Setting it to False // indicates that an error has occurred, and the Load method raises the exception that got // you here. e.Continue = true; }
private void OnFillErrorHandler(Exception e, DataTable dataTable, object[] dataValues) { FillErrorEventArgs args = new FillErrorEventArgs(dataTable, dataValues) { Errors = e }; this.OnFillError(args); if (!args.Continue) { if (args.Errors != null) { throw args.Errors; } throw e; } }
protected virtual void OnFillError(FillErrorEventArgs value) { FillErrorEventHandler handler = (FillErrorEventHandler) base.Events[EventFillError]; if (handler != null) { handler(this, value); } }
private static void da_FillError(object sender, FillErrorEventArgs e) { fillError = e.Errors.Message; e.Continue = true; }
static void adapter_FillError(object sender, FillErrorEventArgs e) { }
private void dbDA_FillError(object sender, FillErrorEventArgs args) { blnReadDBData_Fill = true; args.Continue = false; }
internal override void OnFillErrorInternal (FillErrorEventArgs value) { OnFillError (value); }
void ErrorHandler (object sender, FillErrorEventArgs args) { args.Continue = FillErrorContinue; }
internal static int FillFromReader (DataTable table, IDataReader reader, int start, int length, int [] mapping, LoadOption loadOption, FillErrorEventHandler errorHandler) { if (reader.FieldCount == 0) return 0 ; for (int i = 0; i < start; i++) reader.Read (); int counter = 0; object [] values = new object [mapping.Length]; while (reader.Read () && (length == 0 || counter < length)) { for (int i = 0 ; i < mapping.Length; i++) values [i] = mapping [i] < 0 ? null : reader [mapping [i]]; table.BeginLoadData (); try { table.LoadDataRow (values, loadOption); } catch (Exception e) { FillErrorEventArgs args = new FillErrorEventArgs (table, values); args.Errors = e; args.Continue = false; errorHandler (table, args); // if args.Continue is not set to true or if a handler is not set, rethrow the error.. if(!args.Continue) throw e; } table.EndLoadData (); counter++; } return counter; }
protected virtual void OnFillError (FillErrorEventArgs value) { if (FillError != null) FillError (this, value); }
private void fillErrorHandler (object sender, FillErrorEventArgs e) { e.Continue = fillErr[fillErrCounter].contFlag; Assert.AreEqual (fillErr[fillErrCounter].tableName, e.DataTable.TableName, "fillErr-T"); Assert.AreEqual (fillErr[fillErrCounter].contFlag, e.Continue, "fillErr-C"); fillErrCounter++; }
private void fillErrorHandler (object sender, FillErrorEventArgs e) { e.Continue = fillErr[fillErrCounter].contFlag; Assert.AreEqual (fillErr[fillErrCounter].tableName, e.DataTable.TableName, "fillErr-T"); //Assert.AreEqual (fillErr[fillErrCounter].rowKey, e.Values[0], "fillErr-R"); Assert.AreEqual (fillErr[fillErrCounter].contFlag, e.Continue, "fillErr-C"); //Assert.AreEqual (fillErr[fillErrCounter].error, e.Errors.Message, "fillErr-E"); fillErrCounter++; }
private void OnAdapterFillError(object sender, FillErrorEventArgs e) { e.Continue = true; }