C# DataRow.SetColumnError方法代码示例

        private static bool ISSingleRowValid(DataRow dr)
        {
            dr.ClearErrors();
            bool isValid = true;
            if (dr["InventoryDamagedQuantity"] != DBNull.Value && ((Convert.ToDecimal(dr["InventoryDamagedQuantity"]) > 0) && (dr["DamagedPalletLocationID"] == DBNull.Value)))
            {
                dr.SetColumnError("DamagedPalletLocationID",
                                  Icons.YearEndProcess_ValidateBeforeCommit_DamagedPalletLocation_Can_not_be_left_empty_);
                isValid = false;
            }

            if (dr["InventorySoundQuantity"] != DBNull.Value && ((Convert.ToDecimal(dr["InventorySoundQuantity"]) > 0) && (dr["PalletLocationID"] == DBNull.Value)))
            {
                dr.SetColumnError("PalletLocationID",
                                  Icons.YearEndProcess_ValidateBeforeCommit_Normal_PalletLocation_Can_not_be_left_empty_);
                isValid = false;
            }

            return isValid;
        }

//.........这里部分代码省略.........
            try {
                drcevent = RaiseRowChanging(null, dataRow, action);
                if (action == DataRowAction.Nothing) { // RaiseRowChanging does not fire for DataRowAction.Nothing
                    dataRow.inChangingEvent = true;
                    try {
                        drcevent = OnRowChanging(drcevent, dataRow, action);
                    }
                    finally {
                        dataRow.inChangingEvent = false;
                    }
                }
            }
            finally {
                Debug.Assert(dataRow.tempRecord == recordNo, "tempRecord has been changed in event handler");
                if (DataRowState.Detached == dataRow.RowState) {
                    // 'row.Table.Remove(row);'
                    if (-1 != cacheTempRecord) {
                        FreeRecord(ref cacheTempRecord);
                    }
                }
                else {
                    if (dataRow.tempRecord != recordNo) {
                        // 'row.EndEdit(); row.BeginEdit(); '
                        if (-1 != cacheTempRecord) {
                            FreeRecord(ref cacheTempRecord);
                        }
                        if (-1 != recordNo) {
                            FreeRecord(ref recordNo);
                        }
                        recordNo = dataRow.tempRecord;
                    }
                    else {
                        dataRow.tempRecord = cacheTempRecord;
                    }
                }
            }
            if (dataRow.tempRecord != -1) {
                dataRow.CancelEdit();
            }

            switch(loadOption) {
                case LoadOption.OverwriteChanges:
                     this.SetNewRecord(dataRow,  recordNo, DataRowAction.Change, false, false);
                     this.SetOldRecord(dataRow,  recordNo);
                     break;
                case LoadOption.Upsert:
                     if (dataRow.RowState == DataRowState.Unchanged) {
                         this.SetNewRecord(dataRow,  recordNo, DataRowAction.Change, false, false);
                         if (!dataRow.HasChanges()) {
                             this.SetOldRecord(dataRow, recordNo);
                         }
                     }
                     else {
                         if (dataRow.RowState == DataRowState.Deleted)
                             dataRow.RejectChanges();
                         this.SetNewRecord(dataRow,  recordNo, DataRowAction.Change, false, false);
                     }
                     break;
                case LoadOption.PreserveChanges:
                     if (dataRow.RowState == DataRowState.Unchanged) {
                         // SQLBU 500706: DataTable internal index is corrupted: '8'
                         // if ListChanged event deletes dataRow
                         this.SetOldRecord(dataRow,  recordNo); // do not fire event
                         this.SetNewRecord(dataRow, recordNo, DataRowAction.Change, false, false);
                     }
                     else { // if modified/ added / deleted we want this operation to fire event (just for LoadOption.PreserveCurrentValues)
                        this.SetOldRecord(dataRow,  recordNo);
                     }
                     break;
                default:
                    throw ExceptionBuilder.ArgumentOutOfRange("LoadOption");
            }

            if (hasError) {
                string error = Res.GetString(Res.Load_ReadOnlyDataModified);
                if (dataRow.RowError.Length == 0) { // WebData 112272, append the row error
                    dataRow.RowError = error;
                }
                else {
                    dataRow.RowError += " ]:[ " + error ;
                }

                foreach(DataColumn dc in this.Columns) {
                    if (dc.ReadOnly && !dc.Computed)
                        dataRow.SetColumnError(dc, error);
                }
            }

            drcevent = RaiseRowChanged(drcevent, dataRow, action);
            if (action == DataRowAction.Nothing) { // RaiseRowChanged does not fire for DataRowAction.Nothing
                dataRow.inChangingEvent = true;
                try {
                    OnRowChanged(drcevent, dataRow, action);
                }
                finally {
                    dataRow.inChangingEvent = false;
                }
            }

        }

        internal DataRow MergeRow(DataRow row, DataRow targetRow, bool preserveChanges, Index idxSearch) {
             if (targetRow == null) {
                targetRow = this.NewEmptyRow();
                targetRow.oldRecord = recordManager.ImportRecord(row.Table, row.oldRecord);
                targetRow.newRecord = targetRow.oldRecord;
                if(row.oldRecord != row.newRecord) {
                    targetRow.newRecord = recordManager.ImportRecord(row.Table, row.newRecord);
                }
                InsertRow(targetRow, -1);
            }
            else {
                // SQLBU 500789: Record Manager corruption during Merge when target row in edit state
                // the newRecord would be freed and overwrite tempRecord (which became the newRecord)
                // this would leave the DataRow referencing a freed record and leaking memory for the now lost record
                int proposedRecord = targetRow.tempRecord; // by saving off the tempRecord, EndEdit won't free newRecord
                targetRow.tempRecord = -1;
                try {
                    DataRowState saveRowState = targetRow.RowState;
                    int saveIdxRecord = (saveRowState == DataRowState.Added) ? targetRow.newRecord : saveIdxRecord = targetRow.oldRecord;
                     int newRecord;
                     int oldRecord;
                    if (targetRow.RowState == DataRowState.Unchanged && row.RowState == DataRowState.Unchanged) {
                        // unchanged row merging with unchanged row
                        oldRecord = targetRow.oldRecord;
                        newRecord = (preserveChanges) ? recordManager.CopyRecord(this, oldRecord, -1) : targetRow.newRecord;
                        oldRecord = recordManager.CopyRecord(row.Table, row.oldRecord, targetRow.oldRecord);
                        SetMergeRecords(targetRow, newRecord, oldRecord, DataRowAction.Change);
                    }
                    else if (row.newRecord == -1) {
                        // Incoming row is deleted
                        oldRecord = targetRow.oldRecord;
                        if (preserveChanges) {
                          newRecord = (targetRow.RowState == DataRowState.Unchanged)? recordManager.CopyRecord(this, oldRecord, -1) : targetRow.newRecord;
                        }
                        else
                            newRecord = -1;
                        oldRecord = recordManager.CopyRecord(row.Table, row.oldRecord, oldRecord);

                        // Change index record, need to update index
                        if (saveIdxRecord != ((saveRowState == DataRowState.Added) ? newRecord : oldRecord)) {
                            SetMergeRecords(targetRow, newRecord, oldRecord, (newRecord == -1) ? DataRowAction.Delete : DataRowAction.Change);
                            idxSearch.Reset();
                            saveIdxRecord = ((saveRowState == DataRowState.Added) ? newRecord : oldRecord);
                        } else {
                            SetMergeRecords(targetRow, newRecord, oldRecord, (newRecord == -1) ? DataRowAction.Delete : DataRowAction.Change);
                        }
                    }
                    else {
                        // incoming row is added, modified or unchanged (targetRow is not unchanged)
                        oldRecord = targetRow.oldRecord;
                        newRecord = targetRow.newRecord;
                        if (targetRow.RowState == DataRowState.Unchanged) {
                            newRecord = recordManager.CopyRecord(this, oldRecord, -1);
                        }
                        oldRecord = recordManager.CopyRecord(row.Table, row.oldRecord, oldRecord);

                        if (!preserveChanges) {
                            newRecord = recordManager.CopyRecord(row.Table, row.newRecord, newRecord);
                        }
                        SetMergeRecords(targetRow, newRecord, oldRecord, DataRowAction.Change);
                    }

                    if (saveRowState == DataRowState.Added && targetRow.oldRecord != -1)
                        idxSearch.Reset();
                    Debug.Assert(saveIdxRecord == ((saveRowState == DataRowState.Added) ? targetRow.newRecord : targetRow.oldRecord), "oops, you change index record without noticing it");
                }
                finally {
                    targetRow.tempRecord = proposedRecord;
                }
            }

            // Merge all errors
            if (row.HasErrors) {
                if (targetRow.RowError.Length == 0) {
                    targetRow.RowError = row.RowError;
                } else {
                    targetRow.RowError += " ]:[ " + row.RowError;
                }
                DataColumn[] cols = row.GetColumnsInError();

                for (int i = 0; i < cols.Length; i++) {
                    DataColumn col = targetRow.Table.Columns[cols[i].ColumnName];
                    targetRow.SetColumnError(col, row.GetColumnError(cols[i]));
                }
            }else {
                if (!preserveChanges) {
                    targetRow.ClearErrors();
                }
            }

            return targetRow;
        }

        /*
            Set the row and columns in error.
        */
        private void ConvertToRowError(DataRow row, int rowIndex)
        {
            Debug.Assert(row != null);
            Debug.Assert(_rowErrors != null);
            Debug.Assert(_colErrors != null);

            if (_rowErrors.ContainsKey(rowIndex))
            {
                row.RowError = (string)_rowErrors[rowIndex];
            }
            if (_colErrors.ContainsKey(rowIndex))
            {
                ArrayList list = (ArrayList)_colErrors[rowIndex];
                int[] columnsInError = (int[])list[0];
                string[] columnErrors = (string[])list[1];
                Debug.Assert(columnsInError.Length == columnErrors.Length);
                for (int i = 0; i < columnsInError.Length; i++)
                {
                    row.SetColumnError(columnsInError[i], columnErrors[i]);
                }
            }
        }

		internal void CopyErrors(DataRow row)
		{
			row.RowError = RowError;
			DataColumn[] errorColumns = GetColumnsInError();
			foreach(DataColumn col in errorColumns) {
				DataColumn targetColumn = row.Table.Columns[col.ColumnName];
				row.SetColumnError(targetColumn,GetColumnError(col));
			}
		}

 private void ApplyRowCellValueToBOProperty(DataRow row, UIGridColumn uiProperty, IBusinessObject changedBo)
 {
     string columnName = uiProperty.PropertyName;
     if (!uiProperty.Editable) return;
     IBOPropertyMapper boPropertyMapper = BOPropMapperFactory.CreateMapper(changedBo, columnName);
     boPropertyMapper.SetPropertyValue(row[columnName]);
     row.SetColumnError(columnName, boPropertyMapper.InvalidReason);
 }

        /// <summary>
        /// Check wheather this DataRow is valid.
        /// </summary>
        /// <param name="row"></param>
        /// <returns></returns>
        private bool ValidateData(DataRow row)
        {
            bool valid = true;
            if(row.RowState == DataRowState.Deleted)
                return true;

            row.ClearErrors();

            if(row["UROLE_ID"] == DBNull.Value || row["UROLE_ID"].ToString().Length == 0)
            {
                row.SetColumnError("UROLE_ID", clsResources.GetMessage("errors.required", colURoleID.HeaderText));
                valid = false;
            }

            if(row["ROLE_NAME"] == DBNull.Value || row["ROLE_NAME"].ToString().Length == 0)
            {
                row.SetColumnError("ROLE_NAME", clsResources.GetMessage("errors.required", colRoleName.HeaderText));
                valid = false;
            }

            return valid;
        }

        bool Kiem_tra_dl(DataSet ds, DataRow row)
        {
            if (ds != null)
            {
                foreach (DataRow r in ds.Tables[0].Rows)
                {
                    if (r.RowState != DataRowState.Deleted)
                    {
                        if (r["CTCCV_ID"].ToString() != row["CTCCV_ID"].ToString())
                        {

                            if (row["LCV_ID"].ToString() == r["LCV_ID"].ToString() && row["MO_TA"].ToString().ToLower() == r["MO_TA"].ToString().ToLower())
                            {
                                row.SetColumnError("LCV_ID", "Công việc và mô tả công việc nhập bị trùng lặp!");
                                return false;
                            }
                        }
                    }
                }
            }
            return true;
        }

 private void mergeRows(DataRow org, DataRow chg)
 {
     foreach (DataColumn dc in dtn.Columns)
     {
         if (bAbort)
             return;
         try
         {
             var o = org[dc.ColumnName];
             var c = chg[dc.ColumnName];
             bool bchanged = false;
             bool b = false;
             double d = 0;
             DateTime dt;
             bool ob = false;
             double od = 0;
             DateTime odt;
             if (bool.TryParse(c.ToString(), out b) && bool.TryParse(o.ToString(), out ob))
             {
                 if (!ob.Equals(b))
                 {
                     org[dc.ColumnName] = b;
                     bchanged = true;
                 }
             }
             else if (double.TryParse(c.ToString().Replace(".", ","), out d) && double.TryParse(o.ToString().Replace(".", ","), out od))
             {
                 if (!od.Equals(d))
                 {
                     org[dc.ColumnName] = d;
                     bchanged = true;
                 }
             }
             else if (DateTime.TryParse(c.ToString().Replace(".", ","), out dt) && DateTime.TryParse(o.ToString().Replace(".", ","), out odt))
             {
                 if (!odt.Equals(dt))
                 {
                     org[dc.ColumnName] = dt;
                     bchanged = true;
                 }
             }
             else if (!o.Equals(c))
             {
                 org[dc.ColumnName] = c;
                 bchanged = true;
             }
             continue;
             if (bchanged)
                 org.SetColumnError(dc.ColumnName, string.Format("{0}-{1}", org[dc.ColumnName], chg[dc.ColumnName]));
         }
         catch (ArgumentException ex)
         { }
     }
 }

        private void ValidandoColuna(DataRow row, DataColumn column, object proposedValue)
        {
            if (!_Validacoes.ContainsKey(column))
                return;

            Validacao validation = _Validacoes[column];
            if (validation != null)
            {
                string mensagem = validation.ObterMensagemValidacao(proposedValue);
                row.SetColumnError(column, mensagem);
            }
        }

        private void populateRowWithImportData(DataRow dr, string[] fieldValues, System.Collections.Generic.Dictionary<string, int> columnNameMap, LookupTables lookupTables)
        {
            DataTable dt = dr.Table;
            foreach (string tableColumnName in columnNameMap.Keys)
            {
                // Only update the write enabled columns in this row...
                if (!dt.Columns[tableColumnName].ReadOnly)
                {
                    string newValue = "";
                    DataColumn dc = dt.Columns[tableColumnName];
                    int fieldIndex = columnNameMap[tableColumnName];
                    if (fieldValues.Length <= fieldIndex) continue;
                    // Perform a reverse lookup to get the key if this is a ForeignKey field...
                    if (lookupTables.IsValidFKField(dc))
                    {
                        if (!string.IsNullOrEmpty(fieldValues[fieldIndex].ToString().Trim()))
                        {
                            newValue = lookupTables.GetPKeyValueMember(dr, dc.ExtendedProperties["foreign_key_dataview_name"].ToString(),
                                                                            fieldValues[fieldIndex].ToString().Trim(),
                                                                            -1).ToString();
                            // If the lookup attempt returned the default value - indicate to the user that the lookup failed...
                            if (newValue.Equals("-1"))
                            {
                                dr.SetColumnError(tableColumnName, "\tCould not find lookup value: " + fieldValues[fieldIndex].ToString());
                            }
                        }
                    }
                    // Perform a reverse lookup to get the value if this is a Code_Value field...
                    else if (lookupTables.IsValidCodeValueField(dc))
                    {
                        if (!string.IsNullOrEmpty(fieldValues[fieldIndex].ToString().Trim()))
                        {
                            newValue = lookupTables.GetCodeValueValueMember(fieldValues[fieldIndex].ToString(),
                                                                            dc.ExtendedProperties["group_name"].ToString(),
                                                                            "!Error! - GetValueMember method failed to find display member");
                            // If the lookup attempt returned the default value - indicate to the user that the lookup failed...
                            if (newValue.Equals("!Error! - GetValueMember method failed to find display member"))
                            {
                                dr.SetColumnError(tableColumnName, "\tCould not find lookup value: " + fieldValues[fieldIndex].ToString());
                            }
                        }
                    }
                    // Doesn't require a lookup...
                    else
                    {
                        newValue = fieldValues[fieldIndex];
                    }

                    // If the newValue is null attempt to retrieve the default value before further processing...
                    if (string.IsNullOrEmpty(newValue) &&
                        dt.Columns[tableColumnName].ExtendedProperties.Contains("default_value") &&
                        dt.Columns[tableColumnName].ExtendedProperties["default_value"].ToString().Length > 0)
                    {
                        newValue = dt.Columns[tableColumnName].ExtendedProperties["default_value"].ToString();
                    }

                    // Set the newValue to a default value if it is empty or null...
                    if (string.IsNullOrEmpty(newValue) || newValue == "{DBNull.Value}")
                    {
                        if (dt.Columns[tableColumnName].ExtendedProperties.Contains("is_nullable") &&
                            dt.Columns[tableColumnName].ExtendedProperties["is_nullable"].ToString() == "Y")
                        {
                            if (!dr[tableColumnName].Equals(DBNull.Value) && !dr[tableColumnName].Equals(newValue)) dr[tableColumnName] = DBNull.Value;
                        }
                        else
                        {
                            dr.SetColumnError(tableColumnName, "\tThis value cannot be empty (null)");
                        }
                    }
                    // Convert the newValue string to the datatype for this column...
                    else if ((dt.Columns[tableColumnName].DataType == typeof(int) ||
                                dt.Columns[tableColumnName].DataType == typeof(Int16) ||
                                dt.Columns[tableColumnName].DataType == typeof(Int32) ||
                                dt.Columns[tableColumnName].DataType == typeof(Int64)) &&
                                !dr.GetColumnsInError().Contains(dt.Columns[tableColumnName]))
                    {
                        int tempValue = 0;
                        if (Int32.TryParse(newValue, out tempValue))
                        {
                            if (!dr[tableColumnName].Equals(tempValue)) dr[tableColumnName] = tempValue;
                        }
                        else
                        {
                            dr.SetColumnError(tableColumnName, "\tValue '" + newValue + "' cannot be converted to an integer");
                        }
                    }
                    else if (dt.Columns[tableColumnName].DataType == typeof(Decimal) && !dr.GetColumnsInError().Contains(dt.Columns[tableColumnName]))
                    {
                        Decimal tempValue = new Decimal();
                        if (Decimal.TryParse(newValue, out tempValue))
                        {
                            if (!dr[tableColumnName].Equals(tempValue)) dr[tableColumnName] = tempValue;
                        }
                        else
                        {
                            dr.SetColumnError(tableColumnName, "\tValue '" + newValue + "' cannot be converted to a decimal");
                        }
                    }
                    else if (dt.Columns[tableColumnName].DataType == typeof(DateTime) && !dr.GetColumnsInError().Contains(dt.Columns[tableColumnName]))
                    {
//.........这里部分代码省略.........

 public static void SetError(DataRow Row, string FieldName, string ErrMsg, OutputError Output)
 {
     switch (Output)
     {
         case OutputError.ERROR_PROVIDER:
             Row.SetColumnError(FieldName, ErrMsg);
             break;
     }
 }

//.........这里部分代码省略.........
            finally
            {
                if (DataRowState.Detached == dataRow.RowState)
                {
                    if (-1 != tempRecord)
                    {
                        this.FreeRecord(ref tempRecord);
                    }
                }
                else if (dataRow.tempRecord != recordNo)
                {
                    if (-1 != tempRecord)
                    {
                        this.FreeRecord(ref tempRecord);
                    }
                    if (-1 != recordNo)
                    {
                        this.FreeRecord(ref recordNo);
                    }
                    recordNo = dataRow.tempRecord;
                }
                else
                {
                    dataRow.tempRecord = tempRecord;
                }
            }
            if (dataRow.tempRecord != -1)
            {
                dataRow.CancelEdit();
            }
            switch (loadOption)
            {
                case LoadOption.OverwriteChanges:
                    this.SetNewRecord(dataRow, recordNo, DataRowAction.Change, false, false, false);
                    this.SetOldRecord(dataRow, recordNo);
                    break;

                case LoadOption.PreserveChanges:
                    if (dataRow.RowState != DataRowState.Unchanged)
                    {
                        this.SetOldRecord(dataRow, recordNo);
                        break;
                    }
                    this.SetOldRecord(dataRow, recordNo);
                    this.SetNewRecord(dataRow, recordNo, DataRowAction.Change, false, false, false);
                    break;

                case LoadOption.Upsert:
                    if (dataRow.RowState != DataRowState.Unchanged)
                    {
                        if (dataRow.RowState == DataRowState.Deleted)
                        {
                            dataRow.RejectChanges();
                        }
                        this.SetNewRecord(dataRow, recordNo, DataRowAction.Change, false, false, false);
                        break;
                    }
                    this.SetNewRecord(dataRow, recordNo, DataRowAction.Change, false, false, false);
                    if (!dataRow.HasChanges())
                    {
                        this.SetOldRecord(dataRow, recordNo);
                    }
                    break;

                default:
                    throw ExceptionBuilder.ArgumentOutOfRange("LoadOption");
            }
            if (flag)
            {
                string error = System.Data.Res.GetString("Load_ReadOnlyDataModified");
                if (dataRow.RowError.Length == 0)
                {
                    dataRow.RowError = error;
                }
                else
                {
                    dataRow.RowError = dataRow.RowError + " ]:[ " + error;
                }
                foreach (DataColumn column2 in this.Columns)
                {
                    if (column2.ReadOnly && !column2.Computed)
                    {
                        dataRow.SetColumnError(column2, error);
                    }
                }
            }
            args = this.RaiseRowChanged(args, dataRow, nothing);
            if (nothing == DataRowAction.Nothing)
            {
                dataRow.inChangingEvent = true;
                try
                {
                    this.OnRowChanged(args, dataRow, nothing);
                }
                finally
                {
                    dataRow.inChangingEvent = false;
                }
            }
        }

 internal DataRow MergeRow(DataRow row, DataRow targetRow, bool preserveChanges, Index idxSearch)
 {
     if (targetRow == null)
     {
         targetRow = this.NewEmptyRow();
         targetRow.oldRecord = this.recordManager.ImportRecord(row.Table, row.oldRecord);
         targetRow.newRecord = targetRow.oldRecord;
         if (row.oldRecord != row.newRecord)
         {
             targetRow.newRecord = this.recordManager.ImportRecord(row.Table, row.newRecord);
         }
         this.InsertRow(targetRow, -1L);
     }
     else
     {
         int tempRecord = targetRow.tempRecord;
         targetRow.tempRecord = -1;
         try
         {
             int oldRecord;
             int newRecord;
             int num4;
             DataRowState rowState = targetRow.RowState;
             num4 = (rowState == DataRowState.Added) ? targetRow.newRecord : (num4 = targetRow.oldRecord);
             if ((targetRow.RowState == DataRowState.Unchanged) && (row.RowState == DataRowState.Unchanged))
             {
                 oldRecord = targetRow.oldRecord;
                 newRecord = preserveChanges ? this.recordManager.CopyRecord(this, oldRecord, -1) : targetRow.newRecord;
                 oldRecord = this.recordManager.CopyRecord(row.Table, row.oldRecord, targetRow.oldRecord);
                 this.SetMergeRecords(targetRow, newRecord, oldRecord, DataRowAction.Change);
             }
             else if (row.newRecord == -1)
             {
                 oldRecord = targetRow.oldRecord;
                 if (preserveChanges)
                 {
                     newRecord = (targetRow.RowState == DataRowState.Unchanged) ? this.recordManager.CopyRecord(this, oldRecord, -1) : targetRow.newRecord;
                 }
                 else
                 {
                     newRecord = -1;
                 }
                 oldRecord = this.recordManager.CopyRecord(row.Table, row.oldRecord, oldRecord);
                 if (num4 != ((rowState == DataRowState.Added) ? newRecord : oldRecord))
                 {
                     this.SetMergeRecords(targetRow, newRecord, oldRecord, (newRecord == -1) ? DataRowAction.Delete : DataRowAction.Change);
                     idxSearch.Reset();
                     num4 = (rowState == DataRowState.Added) ? newRecord : oldRecord;
                 }
                 else
                 {
                     this.SetMergeRecords(targetRow, newRecord, oldRecord, (newRecord == -1) ? DataRowAction.Delete : DataRowAction.Change);
                 }
             }
             else
             {
                 oldRecord = targetRow.oldRecord;
                 newRecord = targetRow.newRecord;
                 if (targetRow.RowState == DataRowState.Unchanged)
                 {
                     newRecord = this.recordManager.CopyRecord(this, oldRecord, -1);
                 }
                 oldRecord = this.recordManager.CopyRecord(row.Table, row.oldRecord, oldRecord);
                 if (!preserveChanges)
                 {
                     newRecord = this.recordManager.CopyRecord(row.Table, row.newRecord, newRecord);
                 }
                 this.SetMergeRecords(targetRow, newRecord, oldRecord, DataRowAction.Change);
             }
             if ((rowState == DataRowState.Added) && (targetRow.oldRecord != -1))
             {
                 idxSearch.Reset();
             }
         }
         finally
         {
             targetRow.tempRecord = tempRecord;
         }
     }
     if (row.HasErrors)
     {
         if (targetRow.RowError.Length == 0)
         {
             targetRow.RowError = row.RowError;
         }
         else
         {
             targetRow.RowError = targetRow.RowError + " ]:[ " + row.RowError;
         }
         DataColumn[] columnsInError = row.GetColumnsInError();
         for (int i = 0; i < columnsInError.Length; i++)
         {
             DataColumn column = targetRow.Table.Columns[columnsInError[i].ColumnName];
             targetRow.SetColumnError(column, row.GetColumnError(columnsInError[i]));
         }
         return targetRow;
     }
     if (!preserveChanges)
     {
         targetRow.ClearErrors();
//.........这里部分代码省略.........

        private void CheckErrorTimeCode(DataRow row, BandedGridColumn timeCodeIn, BandedGridColumn timeCodeOut)
        {
            if (row[timeCodeIn.FieldName].ToString() != "" &&
              (row[timeCodeOut.FieldName].ToString() == ""))
            {
                row.SetColumnError(timeCodeOut.FieldName, "Vui lòng vào thông tin \"" + timeCodeOut.Caption + "\"!");
            }
            else if (row[timeCodeIn.FieldName].ToString() == "" &&
                row[timeCodeOut.FieldName].ToString() != "")
            {
                row.SetColumnError(timeCodeIn.FieldName, "Vui lòng vào thông tin \"" + timeCodeIn.Caption + "\"!");

            }
            else if (row[timeCodeIn.FieldName].ToString() != "" &&
                 row[timeCodeOut.FieldName].ToString() != "")
            {
                var tIn = new TimeCode(row[timeCodeIn.FieldName].ToString());
                var tOut = new TimeCode(row[timeCodeOut.FieldName].ToString());
                if (tOut < tIn)
                    row.SetColumnError(timeCodeOut.FieldName, "Vui lòng vào thông tin \"" + timeCodeOut.Caption + "\" lớn hơn \"" + timeCodeIn.Caption + "\"!");
            }
        }