◆ Update() [2/5]

virtual int System.Data.Common.DbDataAdapter.Update	(	DataRow[]	dataRows,
		DataTableMapping	tableMapping )
inlineprotectedvirtual
Definition at line 881 of file DbDataAdapter.cs.
    {
        long scopeId = DataCommonEventSource.Log.EnterScope("<comm.DbDataAdapter.Update|API> {0}, dataRows[], tableMapping", base.ObjectID);
        try
        {
            int num = 0;
            IDbConnection[] array = new IDbConnection[5];
            ConnectionState[] array2 = new ConnectionState[5];
            bool useSelectConnectionState = false;
            IDbCommand selectCommand = _IDbDataAdapter.SelectCommand;
            if (selectCommand != null)
            {
                array[0] = selectCommand.Connection;
                if (array[0] != null)
                {
                    array2[0] = array[0].State;
                    useSelectConnectionState = true;
                }
            }
            int num2 = Math.Min(UpdateBatchSize, dataRows.Length);
            if (num2 < 1)
            {
                num2 = dataRows.Length;
            }
            BatchCommandInfo[] array3 = new BatchCommandInfo[num2];
            DataRow[] array4 = new DataRow[num2];
            int num3 = 0;
            try
            {
                try
                {
                    if (1 != num2)
                    {
                        InitializeBatching();
                    }
                    StatementType statementType = StatementType.Select;
                    IDbCommand dbCommand = null;
                    foreach (DataRow dataRow in dataRows)
                    {
                        if (dataRow == null)
                        {
                            continue;
                        }
                        bool flag = false;
                        DataRowState rowState = dataRow.RowState;
                        if (rowState <= DataRowState.Added)
                        {
                            if ((uint)(rowState - 1) <= 1u)
                            {
                                continue;
                            }
                            if (rowState != DataRowState.Added)
                            {
                                goto IL_0115;
                            }
                            statementType = StatementType.Insert;
                            dbCommand = _IDbDataAdapter.InsertCommand;
                        }
                        else if (rowState != DataRowState.Deleted)
                        {
                            if (rowState != DataRowState.Modified)
                            {
                                goto IL_0115;
                            }
                            statementType = StatementType.Update;
                            dbCommand = _IDbDataAdapter.UpdateCommand;
                        }
                        else
                        {
                            statementType = StatementType.Delete;
                            dbCommand = _IDbDataAdapter.DeleteCommand;
                        }
                        RowUpdatingEventArgs rowUpdatingEventArgs = CreateRowUpdatingEvent(dataRow, dbCommand, statementType, tableMapping);
                        try
                        {
                            dataRow.RowError = null;
                            if (dbCommand != null)
                            {
                                ParameterInput(dbCommand.Parameters, statementType, dataRow, tableMapping);
                            }
                        }
                        catch (Exception ex) when (ADP.IsCatchableExceptionType(ex))
                        {
                            ADP.TraceExceptionForCapture(ex);
                            rowUpdatingEventArgs.Errors = ex;
                            rowUpdatingEventArgs.Status = UpdateStatus.ErrorsOccurred;
                        }
                        OnRowUpdating(rowUpdatingEventArgs);
                        IDbCommand command = rowUpdatingEventArgs.Command;
                        flag = dbCommand != command;
                        dbCommand = command;
                        command = null;
                        UpdateStatus status = rowUpdatingEventArgs.Status;
                        if (status != 0)
                        {
                            if (UpdateStatus.ErrorsOccurred == status)
                            {
                                UpdatingRowStatusErrors(rowUpdatingEventArgs, dataRow);
                                continue;
                            }
                            if (UpdateStatus.SkipCurrentRow == status)
                            {
                                if (DataRowState.Unchanged == dataRow.RowState)
                                {
                                    num++;
                                }
                                continue;
                            }
                            if (UpdateStatus.SkipAllRemainingRows == status)
                            {
                                if (DataRowState.Unchanged == dataRow.RowState)
                                {
                                    num++;
                                }
                                break;
                            }
                            throw ADP.InvalidUpdateStatus(status);
                        }
                        rowUpdatingEventArgs = null;
                        RowUpdatedEventArgs rowUpdatedEventArgs = null;
                        if (1 == num2)
                        {
                            if (dbCommand != null)
                            {
                                array3[0]._commandIdentifier = 0;
                                array3[0]._parameterCount = dbCommand.Parameters.Count;
                                array3[0]._statementType = statementType;
                                array3[0]._updatedRowSource = dbCommand.UpdatedRowSource;
                            }
                            array3[0]._row = dataRow;
                            array4[0] = dataRow;
                            num3 = 1;
                        }
                        else
                        {
                            Exception ex2 = null;
                            try
                            {
                                if (dbCommand != null)
                                {
                                    if ((UpdateRowSource.FirstReturnedRecord & dbCommand.UpdatedRowSource) == 0)
                                    {
                                        array3[num3]._commandIdentifier = AddToBatch(dbCommand);
                                        array3[num3]._parameterCount = dbCommand.Parameters.Count;
                                        array3[num3]._row = dataRow;
                                        array3[num3]._statementType = statementType;
                                        array3[num3]._updatedRowSource = dbCommand.UpdatedRowSource;
                                        array4[num3] = dataRow;
                                        num3++;
                                        if (num3 < num2)
                                        {
                                            continue;
                                        }
                                    }
                                    else
                                    {
                                        ex2 = ADP.ResultsNotAllowedDuringBatch();
                                    }
                                }
                                else
                                {
                                    ex2 = ADP.UpdateRequiresCommand(statementType, flag);
                                }
                            }
                            catch (Exception ex3) when (ADP.IsCatchableExceptionType(ex3))
                            {
                                ADP.TraceExceptionForCapture(ex3);
                                ex2 = ex3;
                            }
                            if (ex2 != null)
                            {
                                rowUpdatedEventArgs = CreateRowUpdatedEvent(dataRow, dbCommand, StatementType.Batch, tableMapping);
                                rowUpdatedEventArgs.Errors = ex2;
                                rowUpdatedEventArgs.Status = UpdateStatus.ErrorsOccurred;
                                OnRowUpdated(rowUpdatedEventArgs);
                                if (ex2 != rowUpdatedEventArgs.Errors)
                                {
                                    for (int j = 0; j < array3.Length; j++)
                                    {
                                        array3[j]._errors = null;
                                    }
                                }
                                num += UpdatedRowStatus(rowUpdatedEventArgs, array3, num3);
                                if (UpdateStatus.SkipAllRemainingRows == rowUpdatedEventArgs.Status)
                                {
                                    break;
                                }
                                continue;
                            }
                        }
                        rowUpdatedEventArgs = CreateRowUpdatedEvent(dataRow, dbCommand, statementType, tableMapping);
                        try
                        {
                            if (1 != num2)
                            {
                                IDbConnection connection = GetConnection1(this);
                                ConnectionState connectionState = UpdateConnectionOpen(connection, StatementType.Batch, array, array2, useSelectConnectionState);
                                rowUpdatedEventArgs.AdapterInit(array4);
                                if (ConnectionState.Open == connectionState)
                                {
                                    UpdateBatchExecute(array3, num3, rowUpdatedEventArgs);
                                }
                                else
                                {
                                    rowUpdatedEventArgs.Errors = ADP.UpdateOpenConnectionRequired(StatementType.Batch, isRowUpdatingCommand: false, connectionState);
                                    rowUpdatedEventArgs.Status = UpdateStatus.ErrorsOccurred;
                                }
                            }
                            else if (dbCommand != null)
                            {
                                IDbConnection connection2 = GetConnection4(this, dbCommand, statementType, flag);
                                ConnectionState connectionState2 = UpdateConnectionOpen(connection2, statementType, array, array2, useSelectConnectionState);
                                if (ConnectionState.Open == connectionState2)
                                {
                                    UpdateRowExecute(rowUpdatedEventArgs, dbCommand, statementType);
                                    array3[0]._recordsAffected = rowUpdatedEventArgs.RecordsAffected;
                                    array3[0]._errors = null;
                                }
                                else
                                {
                                    rowUpdatedEventArgs.Errors = ADP.UpdateOpenConnectionRequired(statementType, flag, connectionState2);
                                    rowUpdatedEventArgs.Status = UpdateStatus.ErrorsOccurred;
                                }
                            }
                            else
                            {
                                rowUpdatedEventArgs.Errors = ADP.UpdateRequiresCommand(statementType, flag);
                                rowUpdatedEventArgs.Status = UpdateStatus.ErrorsOccurred;
                            }
                        }
                        catch (Exception ex4) when (ADP.IsCatchableExceptionType(ex4))
                        {
                            ADP.TraceExceptionForCapture(ex4);
                            rowUpdatedEventArgs.Errors = ex4;
                            rowUpdatedEventArgs.Status = UpdateStatus.ErrorsOccurred;
                        }
                        bool flag2 = UpdateStatus.ErrorsOccurred == rowUpdatedEventArgs.Status;
                        Exception errors = rowUpdatedEventArgs.Errors;
                        OnRowUpdated(rowUpdatedEventArgs);
                        if (errors != rowUpdatedEventArgs.Errors)
                        {
                            for (int k = 0; k < array3.Length; k++)
                            {
                                array3[k]._errors = null;
                            }
                        }
                        num += UpdatedRowStatus(rowUpdatedEventArgs, array3, num3);
                        if (UpdateStatus.SkipAllRemainingRows == rowUpdatedEventArgs.Status)
                        {
                            if (flag2 && 1 != num2)
                            {
                                ClearBatch();
                                num3 = 0;
                            }
                            break;
                        }
                        if (1 != num2)
                        {
                            ClearBatch();
                            num3 = 0;
                        }
                        for (int l = 0; l < array3.Length; l++)
                        {
                            array3[l] = default(BatchCommandInfo);
                        }
                        num3 = 0;
                        continue;
                        IL_0115:
                        throw ADP.InvalidDataRowState(dataRow.RowState);
                    }
                    if (1 != num2 && 0 < num3)
                    {
                        RowUpdatedEventArgs rowUpdatedEventArgs2 = CreateRowUpdatedEvent(null, dbCommand, statementType, tableMapping);
                        try
                        {
                            IDbConnection connection3 = GetConnection1(this);
                            ConnectionState connectionState3 = UpdateConnectionOpen(connection3, StatementType.Batch, array, array2, useSelectConnectionState);
                            DataRow[] array5 = array4;
                            if (num3 < array4.Length)
                            {
                                array5 = new DataRow[num3];
                                Array.Copy(array4, array5, num3);
                            }
                            rowUpdatedEventArgs2.AdapterInit(array5);
                            if (ConnectionState.Open == connectionState3)
                            {
                                UpdateBatchExecute(array3, num3, rowUpdatedEventArgs2);
                            }
                            else
                            {
                                rowUpdatedEventArgs2.Errors = ADP.UpdateOpenConnectionRequired(StatementType.Batch, isRowUpdatingCommand: false, connectionState3);
                                rowUpdatedEventArgs2.Status = UpdateStatus.ErrorsOccurred;
                            }
                        }
                        catch (Exception ex5) when (ADP.IsCatchableExceptionType(ex5))
                        {
                            ADP.TraceExceptionForCapture(ex5);
                            rowUpdatedEventArgs2.Errors = ex5;
                            rowUpdatedEventArgs2.Status = UpdateStatus.ErrorsOccurred;
                        }
                        Exception errors2 = rowUpdatedEventArgs2.Errors;
                        OnRowUpdated(rowUpdatedEventArgs2);
                        if (errors2 != rowUpdatedEventArgs2.Errors)
                        {
                            for (int m = 0; m < array3.Length; m++)
                            {
                                array3[m]._errors = null;
                            }
                        }
                        num += UpdatedRowStatus(rowUpdatedEventArgs2, array3, num3);
                    }
                }
                finally
                {
                    if (1 != num2)
                    {
                        TerminateBatching();
                    }
                }
            }
            finally
            {
                for (int n = 0; n < array.Length; n++)
                {
                    QuietClose(array[n], array2[n]);
                }
            }
            return num;
        }
        finally
        {
            DataCommonEventSource.Log.ExitScope(scopeId);
        }
    }