C# DataRow.AcceptChanges方法代码示例

        private void btnSave_Click(object sender, EventArgs e)
        {
            try
            {
                txtID.Text = txtID.Text.ToUpper();
                if (ValidData())
                    switch (vAction)
                    {
                        case action.Insert:
                            var obj = new LObjectType();
                            obj.SName = Utility.sDbnull(txtName.Text);
                            obj.SDesc = Utility.sDbnull(txtDesc.Text);
                            obj.IsNew = true;
                            obj.Save();

                            drList = dtList.NewRow();
                            drList[LObjectType.Columns.Id] =
                                LObjectType.CreateQuery().GetMax(LObjectType.Columns.Id);
                            ApplyData2Datarow();
                            dtList.Rows.InsertAt(drList, 0);
                            dtList.AcceptChanges();

                            txtID.Text = Utility.sDbnull(drList[LObjectType.Columns.Id]);
                            vAction = action.Update;
                            break;
                        case action.Update:
                            new Update(LObjectType.Schema.Name).Set(LObjectType.Columns.SName).EqualTo(txtName.Text).
                                Set(LObjectType.Columns.SDesc).EqualTo(txtDesc.Text).
                                Where(LObjectType.Columns.Id).IsEqualTo(Utility.Int32Dbnull(txtID.Text)).
                                Execute();
                            ApplyData2Datarow();
                            drList.AcceptChanges();
                            break;
                    }
            }
            catch (Exception ex)
            {
                Utility.ShowMsg(ex.Message);
            }
        }

 //刷新缓存记录的数据
 protected void UpdateSummaryRowState(DataRow dataRow)
 {
     dataRow.AcceptChanges();
     if (_UpdateType == UpdateType.Modify) dataRow.SetModified();
     if (_UpdateType == UpdateType.Add) dataRow.SetAdded();
 }

		private void changeRowStateToModified(DataRow dataRow, changedRows changedRow, DataTable dt)
		{
			//verificar se é possivel forçar a mudança de estado (tabelas intermedias que so sejam compostas por chaves primarias não são permitidas edições)
			if (allowRowStateChanges(dt))
			{
				//forçar a mudança de estado para modified da linha marcada como added
				dataRow.AcceptChanges();
				bool isReadOnly = false;
				isReadOnly = dataRow.Table.Columns[0].ReadOnly;
				dataRow.Table.Columns[0].ReadOnly = false;
				dataRow[0] = dataRow[0];
				dataRow.Table.Columns[0].ReadOnly = isReadOnly;
				changedRow.rowsMod.Add(dataRow);
				RowsChangedToModified.Add(dataRow, dataRow);
			}
			else
			{
				dataRow.AcceptChanges();
			}

			//como a linha já existe na BD esta deve ser removida da lista das added
			changedRow.rowsAdd.Remove(dataRow);

		}

        /// <summary>
        /// Applies the rule
        /// </summary>
        public override void ApplyRule(DataRow row)
        {
            // This method seems inefficient, but it's necessary to handle it in this manner so that the order of
            // variable assignments is maintained across different types of created variables.

            bool assigned = false;

            row.AcceptChanges();

            foreach (DataRowView assignRowView in dvAssign)
            {
                DataRow assignRow = assignRowView.Row;
                if (assignRow == row)
                {
                    assignRow[destinationColumnName] = assignValue;
                    assigned = true;
                    break;
                }
            }

            if (elseValue != null && !assigned)
            {
                row[destinationColumnName] = elseValue;
            }
        }

        private void cmdSave_Click(object sender, EventArgs e)
        {
            try
            {
                txtID.Text = txtID.Text.ToUpper();
                if (ValidData())
                    switch (vAction)
                    {
                        case action.Insert:
                            var obj = new DDataControl();
                            obj.DataName = "";
                            obj.DeviceId = Utility.Int32Dbnull(cboDevice.SelectedValue, -1);
                            obj.DataTypeId = 0;
                            obj.ControlType = true;
                            obj.AliasName = Utility.sDbnull(txtAlias.Text);
                            obj.Description = Utility.sDbnull(txtDesc.Text);
                            obj.IsNew = true;
                            obj.Save();

                            drData = dtDataControl.NewRow();
                            drData[DDataControl.Columns.DataControlId] =
                                DDataControl.CreateQuery().WHERE(DDataControl.Columns.DeviceId,Utility.Int32Dbnull(cboDevice.SelectedValue, -1)).
                                WHERE(DDataControl.Columns.AliasName, txtAlias.Text).GetMax(DDataControl.Columns.DataControlId);
                            txtID.Text = drData[DDataControl.Columns.DataControlId].ToString();
                            ApplyData2Datarow();
                            dtDataControl.Rows.InsertAt(drData, 0);
                            dtDataControl.AcceptChanges();
                            vAction=action.Update;
                            break;
                        case action.Update:
                            new Update(DDataControl.Schema.Name).Set(DDataControl.Columns.AliasName).EqualTo(txtAlias.Text).
                                Set(DDataControl.Columns.Description).EqualTo(txtDesc.Text).
                                Set(DDataControl.Columns.DeviceId).EqualTo(Utility.Int32Dbnull(cboDevice.SelectedValue,-1)).
                                Where(DDataControl.Columns.DataControlId).IsEqualTo(Utility.Int32Dbnull(txtID.Text,-1)).Execute();
                            ApplyData2Datarow();
                            drData.AcceptChanges();
                            break;
                    }
            }
            catch (Exception ex)
            {
                Utility.ShowMsg(ex.Message);
            }
        }

 protected void ConvertNullToEmptyString(DataRow	Row)
 {
     bool	bUnChanged	=	Row.RowState	==	DataRowState.Unchanged;
     DataTable	Tbl	=	Row.Table;
     for(int	I=0;I<Tbl.Columns.Count;I++)
     {
         if(Tbl.Columns[I].DataType	==	typeof(string)	&&	Row[I]	is	DBNull)
         {
             Row[I]	=	"";
         }
     }
     if(bUnChanged)
         Row.AcceptChanges();
 }

 private void UpdateLocalSummaryData(DataRow row, string AFieldName, string ADataValue)
 {
     try
     {
         //DataRow row = gridViewSummary.GetDataRow(ARowHandle);
         row.BeginEdit();
         row[AFieldName] = ADataValue;
         row.AcceptChanges();
         row.EndEdit();
     }
     catch (Exception ex)
     {
         throw new Exception("An error occurred while attempting to update the: " + AFieldName + " field" + Environment.NewLine +
             "of the local Summary Grid with a data value of: " + ADataValue + "." + Environment.NewLine +
             "Error CNF-067 in " + FORM_NAME + ".UpdateLocalSummaryData(): " + ex.Message);
     }
 }

        public void UpdateCell(DataRow row, DataColumn column, object value)
        {
            if (column == colRowID)
                return;

            string col = column.ColumnName;
            int rowId = RowId(row);
            var builder = UpdateClause(col, rowId, value);
            new SqlCmd(builder).ExecuteNonQuery();
            row.AcceptChanges();
        }

		///<summary>
		/// Update <see cref="System.Data.DataRow">row</see>'s fields into the current opened database.
		/// <param name="row">a <see cref="System.Data.DataRow">row</see> </param>
		/// <param name="schema"> a <see cref="SharpQuery.SchemaClass.ISchema">schema</see> </param>
		/// <remarks> it use a transaction for each row, so it's a very long process
		/// if you should update something like 10 000 lines ;o). It's used only by the DataView.
		/// If you need a better way write a "BatchUpdate" function
		/// </remarks>
		///</summary>
		public void UpDateRow(ISchemaClass schema, DataRow row)
		{
			if (schema == null)
			{
				throw new System.ArgumentNullException("schema");
			}

			if (row == null)
			{
				throw new System.ArgumentNullException("row");
			}

			string SQLUpdate = this.UPDATE + " ";
			string SQLWhere = this.WHERE + " ";
			string SQLValues = this.SET + " ";

			SQLUpdate += schema.Name;
			SQLUpdate += " ";

			foreach (DataColumn column in row.Table.Columns)
			{
				if (column.ReadOnly == false
				    && column.AutoIncrement == false
				   )
				{
					SQLValues += schema.Name + "." + AbstractSharpQuerySchemaClass.CheckWhiteSpace(column.ColumnName);
					SQLValues += "=";
					if (column.DataType.Equals(System.Type.GetType("System.String"))
					    || column.DataType.Equals(System.Type.GetType("System.Char"))
					   )
					{
						SQLValues += "'";
					}
					SQLValues += row[column.ColumnName];
					if (column.DataType.Equals(System.Type.GetType("System.String"))
					    || column.DataType.Equals(System.Type.GetType("System.Char"))
					   )
					{
						SQLValues += "'";
					}

					SQLValues += ",";
				}

				SQLWhere += SharpQuery.SchemaClass.AbstractSharpQuerySchemaClass.CheckWhiteSpace(column.ColumnName);
				SQLWhere += "=";
				if (column.DataType.Equals(System.Type.GetType("System.String"))
				    || column.DataType.Equals(System.Type.GetType("System.Char"))
				   )
				{
					SQLWhere += "'";
				}
				SQLWhere += row[column.ColumnName, DataRowVersion.Original];
				if (column.DataType.Equals(System.Type.GetType("System.String"))
				    || column.DataType.Equals(System.Type.GetType("System.Char"))
				   )
				{
					SQLWhere += "'";
				}

				if (row.Table.Columns.IndexOf(column) != (row.Table.Columns.Count - 1))
				{
					SQLWhere += " " + this.AND + " ";
				}
			}

			SQLValues = SQLValues.TrimEnd(new Char[] { ',' });

			this.ExecuteSQL(SQLUpdate + SQLValues + SQLWhere, 0);
			row.AcceptChanges();
		}

        /// <summary>
        /// 由资料行的FileType(文件类型)字段创建图标
        /// </summary>
        /// <param name="sourceRow">资料行</param>
        /// <param name="large">返回的大图标</param>
        /// <param name="small">返回的小图标</param>
        /// <param name="writeRow"></param>
        public static void CreateFileIcon(DataRow sourceRow, out Icon large, out Icon small, bool writeRow)
        {
            string fileType = sourceRow[tb_sys_AttachFile.FFileType].ToString();
            CreateFileIcon(fileType, out large, out small);

            if (writeRow)
            {
                DataRowState state = sourceRow.RowState;

                MemoryStream ms1 = new MemoryStream();
                large.ToBitmap().Save(ms1, ImageFormat.Bmp);
                //sourceRow[tb_sys_AttachF] = ms1.ToArray();
                ms1.Close();

                MemoryStream ms2 = new MemoryStream();
                small.ToBitmap().Save(ms2, ImageFormat.Bmp);
                sourceRow[tb_sys_AttachFile.IconSmall] = ms2.ToArray();
                ms2.Close();

                if (state == DataRowState.Unchanged) sourceRow.AcceptChanges();
            }
        }

        public void InsertRow(DataRow row)
        {
            List<string> columns = new List<string>();
            List<object> values = new List<object>();
            List<SqlExpr> where = new List<SqlExpr>();

            var _columns = TableName.GetTableSchema().Columns;

            foreach (DataColumn column in table.Columns)
            {
                object value = row[column];
                string name = column.ColumnName;
                IColumn _column = _columns[column.ColumnName];

                if (column == colRowID)
                    continue;

                if (value != DBNull.Value)
                {
                    columns.Add(name);
                    values.Add(value);

                    where.Add(name.Equal(value));
                }
                else if (!_column.Nullable)  //add default value to COLUMN NOT NULL
                {
                    Type type = _column.CType.ToType();
                    value = GetDefault(type);
                    columns.Add(name);
                    values.Add(value);

                    where.Add(name.Equal(value));
                }
            }

            var builder = new SqlBuilder().INSERT(TableName, columns.ToArray()).VALUES(values.ToArray());
            new SqlCmd(builder).ExecuteNonQuery();

            builder = new SqlBuilder().SELECT.COLUMNS(SqlExpr.PHYSLOC).FROM(TableName).WHERE(where.AND());
            var loc = new SqlCmd(builder).FillObject<byte[]>();
            LOC.Add(loc);

            row[colRowID] = table.Rows.Count - 1; //this will trigger events ColumnChanged or RowChanged

            row.AcceptChanges();
        }

 public static bool UpdateDbRow(string dbPath, DataRow row)
 {
     using (var connection = GetConnection(dbPath))
     {
         try
         {
             CheckOpenConnection(connection);
             var command = GetUpdateCommand(row, connection);
             command.ExecuteNonQuery();
             row.AcceptChanges();
             return true;
         }
         catch (OleDbException ex)
         {
             Debug.WriteLine(ex.Message);
             throw;
         }
     }
 }

        private void btnSave_Click(object sender, EventArgs e)
        {
            try
            {
                txtID.Text = txtID.Text.ToUpper();
                if (ValidData())
                    switch (vAction)
                    {
                        case action.Insert:
                            var obj = new DDeviceList();
                            obj.DeviceName = Utility.sDbnull(txtName.Text);
                            obj.TestTypeId = Utility.Int32Dbnull(cboTestType.SelectedValue);
                            obj.ManufactureId = Utility.ByteDbnull(cboManufacturer.SelectedValue);
                            obj.Description = Utility.sDbnull(txtDesc.Text);
                            obj.Valid = ckbValid.Checked;
                            obj.IsNew = true;
                            obj.Save();

                            drList = dtList.NewRow();
                            drList[DDeviceList.Columns.DeviceId] = DDeviceList.CreateQuery().GetMax(DDeviceList.Columns.DeviceId);
                            ApplyData2Datarow();
                            dtList.Rows.InsertAt(drList, 0);
                            dtList.AcceptChanges();

                            txtID.Text = Utility.sDbnull(drList[DDeviceList.Columns.DeviceId]);
                            vAction = action.Update;
                            break;
                        case action.Update:
                            new Update(DDeviceList.Schema.Name).Set(DDeviceList.Columns.DeviceName).EqualTo(txtName.Text).
                                Set(DDeviceList.Columns.TestTypeId).EqualTo(Utility.Int32Dbnull(cboTestType.SelectedValue)).
                                Set(DDeviceList.Columns.ManufactureId).EqualTo(Utility.Int32Dbnull(cboManufacturer.SelectedValue)).
                                Set(DDeviceList.Columns.Description).EqualTo(txtDesc.Text).
                                Set(DDeviceList.Columns.Valid).EqualTo(ckbValid.Checked).
                                Where(DDeviceList.Columns.DeviceId).IsEqualTo(Utility.Int32Dbnull(txtID.Text)).
                                Execute();
                            ApplyData2Datarow();
                            drList.AcceptChanges();
                            break;
                    }
            }
            catch (Exception ex)
            {
                Utility.ShowMsg(ex.Message);
            }
        }

 protected override void UpdateData(DataRow row)
 {
     if (row == null)
     {
         data.system.projCommentTA.Update(myDataSet.projComment);
         myDataSet.projects.AcceptChanges();
     }
     else
     {
         data.system.projCommentTA.Update(row);
         row.AcceptChanges();
     }
 }

 /// <summary>
 /// Copy giá trị từ Datarow nguồn chứa dữ liệu SourceRow sang Datarow đích DesTable. 
 /// </summary>
 /// <param name="SourceRow">Datarow nguồn chứa dữ liệu</param>
 /// <param name="DesRow">Datarow đích nơi dữ liệu được chép sang</param>
 public static void CopyData(DataRow SourceRow, ref DataRow DesRow)
 {
     try
     {
         if (SourceRow == null || DesRow == null)
         {
             Utility.ShowMsg("Bạn chưa khởi tạo Datarow nguồn và Datarow đích! Một trong 2 Datarow này đang có giá trị null.");
         }
         foreach (DataColumn col in SourceRow.Table.Columns)
         {
             if (DesRow.Table.Columns.Contains(col.ColumnName) && DesRow.Table.Columns[col.ColumnName].GetType().Equals(SourceRow.Table.Columns[col.ColumnName].GetType()))
                 DesRow[col.ColumnName] = SourceRow[col.ColumnName];
         }
         DesRow.AcceptChanges();
     }
     catch
     {
     }
 }