SetDataRowWithLoadOption()

void System.Data.DataTable.SetDataRowWithLoadOption ( DataRow dataRow, int recordNo, LoadOption loadOption, bool checkReadOnly )

inlineprivateinherited

Definition at line 4492 of file DataTable.cs.

    {
        bool flag = false;
        if (checkReadOnly)
        {
            foreach (DataColumn column in Columns)
            {
                if (!column.ReadOnly || column.Computed)
                {
                    continue;
                }
                switch (loadOption)
                {
                case LoadOption.OverwriteChanges:
                    if (dataRow[column, DataRowVersion.Current] != column[recordNo] || dataRow[column, DataRowVersion.Original] != column[recordNo])
                    {
                        flag = true;
                    }
                    break;
                case LoadOption.Upsert:
                    if (dataRow[column, DataRowVersion.Current] != column[recordNo])
                    {
                        flag = true;
                    }
                    break;
                case LoadOption.PreserveChanges:
                    if (dataRow[column, DataRowVersion.Original] != column[recordNo])
                    {
                        flag = true;
                    }
                    break;
                }
            }
        }
        DataRowChangeEventArgs args = null;
        DataRowAction dataRowAction = DataRowAction.Nothing;
        int record = dataRow._tempRecord;
        dataRow._tempRecord = recordNo;
        switch (loadOption)
        {
        case LoadOption.OverwriteChanges:
            dataRowAction = DataRowAction.ChangeCurrentAndOriginal;
            break;
        case LoadOption.Upsert:
            switch (dataRow.RowState)
            {
            case DataRowState.Unchanged:
                foreach (DataColumn column2 in dataRow.Table.Columns)
                {
                    if (column2.Compare(dataRow._newRecord, recordNo) != 0)
                    {
                        dataRowAction = DataRowAction.Change;
                        break;
                    }
                }
                break;
            default:
                dataRowAction = DataRowAction.Change;
                break;
            case DataRowState.Deleted:
                break;
            }
            break;
        case LoadOption.PreserveChanges:
        {
            DataRowState rowState = dataRow.RowState;
            DataRowAction dataRowAction2 = ((rowState != DataRowState.Unchanged) ? DataRowAction.ChangeOriginal : DataRowAction.ChangeCurrentAndOriginal);
            dataRowAction = dataRowAction2;
            break;
        }
        default:
            throw ExceptionBuilder.ArgumentOutOfRange("LoadOption");
        }
        try
        {
            args = RaiseRowChanging(null, dataRow, dataRowAction);
            if (dataRowAction == DataRowAction.Nothing)
            {
                dataRow._inChangingEvent = true;
                try
                {
                    args = OnRowChanging(args, dataRow, dataRowAction);
                }
                finally
                {
                    dataRow._inChangingEvent = false;
                }
            }
        }
        finally
        {
            if (DataRowState.Detached == dataRow.RowState)
            {
                if (-1 != record)
                {
                    FreeRecord(ref record);
                }
            }
            else if (dataRow._tempRecord != recordNo)
            {
                if (-1 != record)
                {
                    FreeRecord(ref record);
                }
                if (-1 != recordNo)
                {
                    FreeRecord(ref recordNo);
                }
                recordNo = dataRow._tempRecord;
            }
            else
            {
                dataRow._tempRecord = record;
            }
        }
        if (dataRow._tempRecord != -1)
        {
            dataRow.CancelEdit();
        }
        switch (loadOption)
        {
        case LoadOption.OverwriteChanges:
            SetNewRecord(dataRow, recordNo, DataRowAction.Change, isInMerge: false, fireEvent: false);
            SetOldRecord(dataRow, recordNo);
            break;
        case LoadOption.Upsert:
            if (dataRow.RowState == DataRowState.Unchanged)
            {
                SetNewRecord(dataRow, recordNo, DataRowAction.Change, isInMerge: false, fireEvent: false);
                if (!dataRow.HasChanges())
                {
                    SetOldRecord(dataRow, recordNo);
                }
            }
            else
            {
                if (dataRow.RowState == DataRowState.Deleted)
                {
                    dataRow.RejectChanges();
                }
                SetNewRecord(dataRow, recordNo, DataRowAction.Change, isInMerge: false, fireEvent: false);
            }
            break;
        case LoadOption.PreserveChanges:
            if (dataRow.RowState == DataRowState.Unchanged)
            {
                SetOldRecord(dataRow, recordNo);
                SetNewRecord(dataRow, recordNo, DataRowAction.Change, isInMerge: false, fireEvent: false);
            }
            else
            {
                SetOldRecord(dataRow, recordNo);
            }
            break;
        default:
            throw ExceptionBuilder.ArgumentOutOfRange("LoadOption");
        }
        if (flag)
        {
            string load_ReadOnlyDataModified = System.SR.Load_ReadOnlyDataModified;
            if (dataRow.RowError.Length == 0)
            {
                dataRow.RowError = load_ReadOnlyDataModified;
            }
            else
            {
                dataRow.RowError = dataRow.RowError + " ]:[ " + load_ReadOnlyDataModified;
            }
            foreach (DataColumn column3 in Columns)
            {
                if (column3.ReadOnly && !column3.Computed)
                {
                    dataRow.SetColumnError(column3, load_ReadOnlyDataModified);
                }
            }
        }
        args = RaiseRowChanged(args, dataRow, dataRowAction);
        if (dataRowAction == DataRowAction.Nothing)
        {
            dataRow._inChangingEvent = true;
            try
            {
                OnRowChanged(args, dataRow, dataRowAction);
            }
            finally
            {
                dataRow._inChangingEvent = false;
            }
        }
    }

References System.Data.ExceptionBuilder.ArgumentOutOfRange(), System.Data.DataTable.Columns, System.Runtime.Serialization.Dictionary, System.Data.DataTable.FreeRecord(), System.SR.Load_ReadOnlyDataModified, System.Data.DataTable.OnRowChanged(), System.Data.DataTable.OnRowChanging(), System.Data.DataTable.RaiseRowChanged(), System.Data.DataTable.RaiseRowChanging(), System.Data.DataTable.SetNewRecord(), and System.Data.DataTable.SetOldRecord().

Referenced by System.Data.DataTable.LoadRow().