private void SetDataRowWithLoadOption (DataRow dataRow, int recordNo, LoadOption loadOption, bool checkReadOnly) {
bool hasError = false;
if (checkReadOnly) {
foreach(DataColumn dc in this.Columns) {
if (dc.ReadOnly && !dc.Computed) {
switch(loadOption) {
case LoadOption.OverwriteChanges:
if ((dataRow[dc, DataRowVersion.Current] != dc[recordNo]) ||(dataRow[dc, DataRowVersion.Original] != dc[recordNo]))
hasError = true;
break;
case LoadOption.Upsert:
if (dataRow[dc, DataRowVersion.Current] != dc[recordNo])
hasError = true;
break;
case LoadOption.PreserveChanges:
if (dataRow[dc, DataRowVersion.Original] != dc[recordNo])
hasError = true;
break;
}
}
}
} // No Event should be fired in SenNewRecord and SetOldRecord
// fire rowChanging event here
DataRowChangeEventArgs drcevent = null;
DataRowAction action = DataRowAction.Nothing;
int cacheTempRecord = dataRow.tempRecord;
dataRow.tempRecord = recordNo;
switch(loadOption) {
case LoadOption.OverwriteChanges:
action = DataRowAction.ChangeCurrentAndOriginal;
break;
case LoadOption.Upsert:
switch(dataRow.RowState) {
case DataRowState.Unchanged:
// let see if the incomming value has the same values as existing row, so compare records
foreach(DataColumn dc in dataRow.Table.Columns) {
if (0 != dc.Compare(dataRow.newRecord, recordNo)) {
action = DataRowAction.Change;
break;
}
}
break;
case DataRowState.Deleted:
Debug.Assert(false, "LoadOption.Upsert with deleted row, should not be here");
break;
default :
action = DataRowAction.Change;
break;
}
break;
case LoadOption.PreserveChanges:
switch(dataRow.RowState) {
case DataRowState.Unchanged:
action = DataRowAction.ChangeCurrentAndOriginal;
break;
default:
action = DataRowAction.ChangeOriginal;
break;
}
break;
default:
throw ExceptionBuilder.ArgumentOutOfRange("LoadOption");
}
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;
}
}
}
private void SetDataRowWithLoadOption(DataRow dataRow, int recordNo, LoadOption loadOption, bool checkReadOnly)
{
bool flag = false;
if (checkReadOnly)
{
foreach (DataColumn column in this.Columns)
{
if (column.ReadOnly && !column.Computed)
{
switch (loadOption)
{
case LoadOption.OverwriteChanges:
goto Label_0058;
case LoadOption.PreserveChanges:
if (dataRow[column, DataRowVersion.Original] != column[recordNo])
{
flag = true;
}
break;
case LoadOption.Upsert:
if (dataRow[column, DataRowVersion.Current] != column[recordNo])
{
flag = true;
}
break;
}
}
continue;
Label_0058:
if ((dataRow[column, DataRowVersion.Current] != column[recordNo]) || (dataRow[column, DataRowVersion.Original] != column[recordNo]))
{
flag = true;
}
}
}
DataRowChangeEventArgs args = null;
DataRowAction nothing = DataRowAction.Nothing;
int tempRecord = dataRow.tempRecord;
dataRow.tempRecord = recordNo;
switch (loadOption)
{
case LoadOption.OverwriteChanges:
nothing = DataRowAction.ChangeCurrentAndOriginal;
break;
case LoadOption.PreserveChanges:
if (dataRow.RowState != DataRowState.Unchanged)
{
nothing = DataRowAction.ChangeOriginal;
break;
}
nothing = DataRowAction.ChangeCurrentAndOriginal;
break;
case LoadOption.Upsert:
switch (dataRow.RowState)
{
case DataRowState.Unchanged:
foreach (DataColumn column3 in dataRow.Table.Columns)
{
if (column3.Compare(dataRow.newRecord, recordNo) != 0)
{
nothing = DataRowAction.Change;
break;
}
}
goto Label_01A4;
}
nothing = DataRowAction.Change;
break;
default:
throw ExceptionBuilder.ArgumentOutOfRange("LoadOption");
}
Label_01A4:;
try
{
args = this.RaiseRowChanging(null, dataRow, nothing);
if (nothing == DataRowAction.Nothing)
{
dataRow.inChangingEvent = true;
try
{
args = this.OnRowChanging(args, dataRow, nothing);
}
finally
{
dataRow.inChangingEvent = false;
}
}
}
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;
}
}
}
