本文整理汇总了C#中System.Data.DataRow.GetParentRows方法的典型用法代码示例。如果您正苦于以下问题:C# DataRow.GetParentRows方法的具体用法?C# DataRow.GetParentRows怎么用?C# DataRow.GetParentRows使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类System.Data.DataRow
的用法示例。
在下文中一共展示了DataRow.GetParentRows方法的9个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: SetNewRecordWorker
private void SetNewRecordWorker(DataRow row, int proposedRecord, DataRowAction action, bool isInMerge, bool suppressEnsurePropertyChanged,
int position, bool fireEvent, out Exception deferredException) {
// this is the event workhorse... it will throw the changing/changed events
// and update the indexes. Used by change, add, delete, revert.
// order of execution is as follows
//
// 1) set temp record
// 2) Check constraints for non-expression columns
// 3) Raise RowChanging/RowDeleting with temp record
// 4) set the new record in storage
// 5) Update indexes with recordStateChanges - this will fire ListChanged & PropertyChanged events on associated views
// 6) Evaluate all Expressions (exceptions are deferred)- this will fire ListChanged & PropertyChanged events on associated views
// 7) Raise RowChanged/ RowDeleted
// 8) Check constraints for expression columns
Debug.Assert(row != null, "Row can't be null.");
deferredException = null;
if (row.tempRecord != proposedRecord) {
// $HACK: for performance reasons, EndUpdate calls SetNewRecord with tempRecord == proposedRecord
if (!inDataLoad) {
row.CheckInTable();
CheckNotModifying(row);
}
if (proposedRecord == row.newRecord) {
if (isInMerge) {
Debug.Assert(fireEvent, "SetNewRecord is called with wrong parameter");
RaiseRowChanged(null, row, action);
}
return;
}
Debug.Assert(!row.inChangingEvent, "How can this row be in an infinite loop?");
row.tempRecord = proposedRecord;
}
DataRowChangeEventArgs drcevent = null;
try {
row._action = action;
drcevent = RaiseRowChanging(null, row, action, fireEvent);
}
catch {
row.tempRecord = -1;
throw;
}
finally {
row._action = DataRowAction.Nothing;
}
row.tempRecord = -1;
int currentRecord = row.newRecord;
// if we're deleting, then the oldRecord value will change, so need to track that if it's distinct from the newRecord.
int secondRecord = (proposedRecord != -1 ?
proposedRecord :
(row.RowState != DataRowState.Unchanged ?
row.oldRecord :
-1));
if (action == DataRowAction.Add) { //if we come here from insert we do insert the row to collection
if (position == -1)
Rows.ArrayAdd(row);
else
Rows.ArrayInsert(row, position);
}
List<DataRow> cachedRows = null;
if ((action == DataRowAction.Delete || action == DataRowAction.Change)
&& dependentColumns != null && dependentColumns.Count > 0) {
// if there are expression columns, need to cache related rows for deletes and updates (key changes)
// before indexes are modified.
cachedRows = new List<DataRow>();
for (int j = 0; j < ParentRelations.Count; j++) {
DataRelation relation = ParentRelations[j];
if (relation.ChildTable != row.Table) {
continue;
}
cachedRows.InsertRange(cachedRows.Count, row.GetParentRows(relation));
}
for (int j = 0; j < ChildRelations.Count; j++) {
DataRelation relation = ChildRelations[j];
if (relation.ParentTable != row.Table) {
continue;
}
cachedRows.InsertRange(cachedRows.Count, row.GetChildRows(relation));
}
}
// Dev10 Bug 688779: DataRowView.PropertyChanged are not raised on RejectChanges
// if the newRecord is changing, the propertychanged event should be allowed to triggered for ListChangedType.Changed or .Moved
// unless the specific condition is known that no data has changed, like DataRow.SetModified()
if (!suppressEnsurePropertyChanged && !row.HasPropertyChanged && (row.newRecord != proposedRecord)
&& (-1 != proposedRecord) // explictly not fixing Dev10 Bug 692044: DataRowView.PropertyChanged are not raised on DataTable.Delete when mixing current and original records in RowStateFilter
&& (-1 != row.newRecord)) // explictly not fixing parts of Dev10 Bug 697909: when mixing current and original records in RowStateFilter
{
//.........这里部分代码省略.........
示例2: EvaluateDependentExpressions
internal void EvaluateDependentExpressions(List<DataColumn> columns, DataRow row, DataRowVersion version, List<DataRow> cachedRows) {
if (columns == null)
return;
//Expression evaluation is done first over same table expressions.
int count = columns.Count;
for(int i = 0; i < count; i++) {
if (columns[i].Table == this) {// if this column is in my table
DataColumn dc = columns[i];
if (dc.DataExpression != null && dc.DataExpression.HasLocalAggregate()) {
// if column expression references a local Table aggregate we need to recalc it for the each row in the local table
DataRowVersion expressionVersion = (version == DataRowVersion.Proposed) ? DataRowVersion.Default : version;
bool isConst = dc.DataExpression.IsTableAggregate(); //is expression constant for entire table?
object newValue = null;
if (isConst) { //if new value, just compute once
newValue = dc.DataExpression.Evaluate(row, expressionVersion);
}
for (int j = 0; j < Rows.Count; j++) { //evaluate for all rows in the table
DataRow dr = Rows[j];
if (dr.RowState == DataRowState.Deleted) {
continue;
}
else if (expressionVersion == DataRowVersion.Original && (dr.oldRecord == -1 || dr.oldRecord == dr.newRecord)) {
continue;
}
if (!isConst) {
newValue = dc.DataExpression.Evaluate(dr, expressionVersion);
}
SilentlySetValue(dr, dc, expressionVersion, newValue);
}
}
else {
if (row.RowState == DataRowState.Deleted) {
continue;
}
else if (version == DataRowVersion.Original && (row.oldRecord == -1 || row.oldRecord == row.newRecord)) {
continue;
}
SilentlySetValue(row, dc, version, dc.DataExpression == null ? dc.DefaultValue : dc.DataExpression.Evaluate(row, version));
}
}
}
// now do expression evaluation for expression columns other tables.
count = columns.Count;
for(int i = 0; i < count; i++) {
DataColumn dc = columns[i];
// if this column is NOT in my table or it is in the table and is not a local aggregate (self refs)
if (dc.Table != this || (dc.DataExpression != null && !dc.DataExpression.HasLocalAggregate())) {
DataRowVersion foreignVer = (version == DataRowVersion.Proposed) ? DataRowVersion.Default : version;
// first - evaluate expressions for cachedRows (deletes & updates)
if (cachedRows != null) {
foreach (DataRow cachedRow in cachedRows) {
if (cachedRow.Table != dc.Table)
continue;
// don't update original version if child row doesn't have an oldRecord.
if (foreignVer == DataRowVersion.Original && cachedRow.newRecord == cachedRow.oldRecord)
continue;
if (cachedRow != null && ((cachedRow.RowState != DataRowState.Deleted) && (version != DataRowVersion.Original || cachedRow.oldRecord != -1))) {// if deleted GetRecordFromVersion will throw
object newValue = dc.DataExpression.Evaluate(cachedRow, foreignVer);
SilentlySetValue(cachedRow, dc, foreignVer, newValue);
}
}
}
// next check parent relations
for (int j = 0; j < ParentRelations.Count; j++) {
DataRelation relation = ParentRelations[j];
if (relation.ParentTable != dc.Table)
continue;
foreach (DataRow parentRow in row.GetParentRows(relation, version)) {
if (cachedRows != null && cachedRows.Contains(parentRow))
continue;
// don't update original version if child row doesn't have an oldRecord.
if (foreignVer == DataRowVersion.Original && parentRow.newRecord == parentRow.oldRecord)
continue;
if (parentRow != null && ((parentRow.RowState != DataRowState.Deleted) && (version != DataRowVersion.Original || parentRow.oldRecord != -1))) {// if deleted GetRecordFromVersion will throw
object newValue = dc.DataExpression.Evaluate(parentRow, foreignVer);
SilentlySetValue(parentRow, dc, foreignVer, newValue);
}
}
}
// next check child relations
for (int j = 0; j < ChildRelations.Count; j++) {
DataRelation relation = ChildRelations[j];
if (relation.ChildTable != dc.Table)
continue;
foreach (DataRow childRow in row.GetChildRows(relation, version)) {
// don't update original version if child row doesn't have an oldRecord.
if (cachedRows != null && cachedRows.Contains(childRow))
continue;
if (foreignVer == DataRowVersion.Original && childRow.newRecord == childRow.oldRecord)
continue;
if (childRow != null && ((childRow.RowState != DataRowState.Deleted) && (version != DataRowVersion.Original || childRow.oldRecord != -1))) { // if deleted GetRecordFromVersion will throw
object newValue = dc.DataExpression.Evaluate(childRow, foreignVer);
SilentlySetValue(childRow, dc, foreignVer, newValue);
}
}
}
}
//.........这里部分代码省略.........
示例3: MarkRelatedRowsAsModified
private void MarkRelatedRowsAsModified(TableChanges[] bitMatrix, DataRow row)
{
DataRelationCollection parentRelations = row.Table.ParentRelations;
int count = parentRelations.Count;
for (int i = 0; i < count; i++)
{
foreach (DataRow row2 in row.GetParentRows(parentRelations[i], DataRowVersion.Current))
{
int index = this.Tables.IndexOf(row2.Table);
int num3 = row2.Table.Rows.IndexOf(row2);
if (!bitMatrix[index][num3])
{
bitMatrix[index][num3] = true;
if (DataRowState.Deleted != row2.RowState)
{
this.MarkRelatedRowsAsModified(bitMatrix, row2);
}
}
}
}
}
示例4: GetReferencedRows
public DataRow[] GetReferencedRows (DataRow row)
{
// Verify the column reference is valid
GetColumn (row);
switch (refTable) {
case ReferencedTable.Self:
default:
DataRow[] rows = row.Table.NewRowArray(row.Table.Rows.Count);
row.Table.Rows.CopyTo (rows, 0);
return rows;
case ReferencedTable.Parent:
return row.GetParentRows (GetRelation (row));
case ReferencedTable.Child:
return row.GetChildRows (GetRelation (row));
}
}
示例5: parentsExists
private static bool parentsExists(DataRow row)
{
if (row.Table.ParentRelations.Count == 0)
return true;
foreach (DataRelation rel in row.Table.ParentRelations)
return row.GetParentRows(rel).Length > 0;
return false;
}
示例6: MarkRelatedRowsAsModified
private void MarkRelatedRowsAsModified(TableChanges[] bitMatrix, DataRow row) {
DataRelationCollection relations = row.Table.ParentRelations;
int relationCount = relations.Count;
for (int relatedIndex = 0; relatedIndex < relationCount; ++relatedIndex) {
DataRow[] relatedRows = row.GetParentRows(relations[relatedIndex], DataRowVersion.Current);
foreach (DataRow relatedRow in relatedRows) {
int relatedTableIndex = this.Tables.IndexOf(relatedRow.Table);
int relatedRowIndex = relatedRow.Table.Rows.IndexOf(relatedRow);
if (!bitMatrix[relatedTableIndex][relatedRowIndex]) {
bitMatrix[relatedTableIndex][relatedRowIndex] = true;
if (DataRowState.Deleted != relatedRow.RowState) {
// recurse into related rows
MarkRelatedRowsAsModified(bitMatrix, relatedRow);
}
}
}
}
}
示例7: ParentRowTest2
public void ParentRowTest2 ()
{
DataSet ds = new DataSet ();
DataTable tableP = ds.Tables.Add ("Parent");
DataTable tableC = ds.Tables.Add ("Child");
DataColumn colC;
DataRow rowC;
colC = new DataColumn ();
colC.DataType = Type.GetType ("System.Int32");
colC.ColumnName = "Id";
colC.AutoIncrement = true;
tableP.Columns.Add (colC);
colC = new DataColumn ();
colC.DataType = Type.GetType ("System.Int32");
colC.ColumnName = "Id";
tableC.Columns.Add (colC);
row = tableP.Rows.Add (new object [0]);
rowC = tableC.NewRow ();
ds.EnforceConstraints = false;
DataRelation dr = new DataRelation ("PO", tableP.Columns ["Id"], tableC.Columns ["Id"]);
ds.Relations.Add (dr);
rowC.SetParentRow (row, dr);
DataRow [] rows = rowC.GetParentRows (dr);
AssertEquals ("#A49", 1, rows.Length);
AssertEquals ("#A50", tableP.Rows [0], rows [0]);
try{
rows = row.GetParentRows (dr);
}catch(InvalidConstraintException){
//Test done
return ;
}catch(Exception e){
Fail("#A51, InvalidConstraintException expected, got : " + e);
}
Fail("#A52, InvalidConstraintException expected but got none.");
}
示例8: SetNewRecordWorker
private void SetNewRecordWorker(DataRow row, int proposedRecord, DataRowAction action, bool isInMerge, bool suppressEnsurePropertyChanged, int position, bool fireEvent, out Exception deferredException)
{
deferredException = null;
if (row.tempRecord != proposedRecord)
{
if (!this.inDataLoad)
{
row.CheckInTable();
this.CheckNotModifying(row);
}
if (proposedRecord == row.newRecord)
{
if (isInMerge)
{
this.RaiseRowChanged(null, row, action);
}
return;
}
row.tempRecord = proposedRecord;
}
DataRowChangeEventArgs args = null;
try
{
row._action = action;
args = this.RaiseRowChanging(null, row, action, fireEvent);
}
catch
{
row.tempRecord = -1;
throw;
}
finally
{
row._action = DataRowAction.Nothing;
}
row.tempRecord = -1;
int newRecord = row.newRecord;
int record = (proposedRecord != -1) ? proposedRecord : ((row.RowState != DataRowState.Unchanged) ? row.oldRecord : -1);
if (action == DataRowAction.Add)
{
if (position == -1)
{
this.Rows.ArrayAdd(row);
}
else
{
this.Rows.ArrayInsert(row, position);
}
}
List<DataRow> cachedRows = null;
if (((action == DataRowAction.Delete) || (action == DataRowAction.Change)) && ((this.dependentColumns != null) && (this.dependentColumns.Count > 0)))
{
cachedRows = new List<DataRow>();
for (int i = 0; i < this.ParentRelations.Count; i++)
{
DataRelation relation2 = this.ParentRelations[i];
if (relation2.ChildTable == row.Table)
{
cachedRows.InsertRange(cachedRows.Count, row.GetParentRows(relation2));
}
}
for (int j = 0; j < this.ChildRelations.Count; j++)
{
DataRelation relation = this.ChildRelations[j];
if (relation.ParentTable == row.Table)
{
cachedRows.InsertRange(cachedRows.Count, row.GetChildRows(relation));
}
}
}
if (((!suppressEnsurePropertyChanged && !row.HasPropertyChanged) && ((row.newRecord != proposedRecord) && (-1 != proposedRecord))) && (-1 != row.newRecord))
{
row.LastChangedColumn = null;
row.LastChangedColumn = null;
}
if (this.LiveIndexes.Count != 0)
{
if (((-1 == newRecord) && (-1 != proposedRecord)) && ((-1 != row.oldRecord) && (proposedRecord != row.oldRecord)))
{
newRecord = row.oldRecord;
}
DataViewRowState recordState = row.GetRecordState(newRecord);
DataViewRowState state3 = row.GetRecordState(record);
row.newRecord = proposedRecord;
if (proposedRecord != -1)
{
this.recordManager[proposedRecord] = row;
}
DataViewRowState state2 = row.GetRecordState(newRecord);
DataViewRowState state = row.GetRecordState(record);
this.RecordStateChanged(newRecord, recordState, state2, record, state3, state);
}
else
{
row.newRecord = proposedRecord;
if (proposedRecord != -1)
{
this.recordManager[proposedRecord] = row;
}
}
//.........这里部分代码省略.........
示例9: EvaluateDependentExpressions
internal void EvaluateDependentExpressions(List<DataColumn> columns, DataRow row, DataRowVersion version, List<DataRow> cachedRows)
{
if (columns != null)
{
int count = columns.Count;
for (int i = 0; i < count; i++)
{
if (columns[i].Table == this)
{
DataColumn dc = columns[i];
if ((dc.DataExpression != null) && dc.DataExpression.HasLocalAggregate())
{
DataRowVersion version3 = (version == DataRowVersion.Proposed) ? DataRowVersion.Default : version;
bool flag = dc.DataExpression.IsTableAggregate();
object newValue = null;
if (flag)
{
newValue = dc.DataExpression.Evaluate(row, version3);
}
for (int k = 0; k < this.Rows.Count; k++)
{
DataRow row5 = this.Rows[k];
if ((row5.RowState != DataRowState.Deleted) && ((version3 != DataRowVersion.Original) || ((row5.oldRecord != -1) && (row5.oldRecord != row5.newRecord))))
{
if (!flag)
{
newValue = dc.DataExpression.Evaluate(row5, version3);
}
this.SilentlySetValue(row5, dc, version3, newValue);
}
}
}
else if ((row.RowState != DataRowState.Deleted) && ((version != DataRowVersion.Original) || ((row.oldRecord != -1) && (row.oldRecord != row.newRecord))))
{
this.SilentlySetValue(row, dc, version, (dc.DataExpression == null) ? dc.DefaultValue : dc.DataExpression.Evaluate(row, version));
}
}
}
count = columns.Count;
for (int j = 0; j < count; j++)
{
DataColumn column = columns[j];
if ((column.Table != this) || ((column.DataExpression != null) && !column.DataExpression.HasLocalAggregate()))
{
DataRowVersion version2 = (version == DataRowVersion.Proposed) ? DataRowVersion.Default : version;
if (cachedRows != null)
{
foreach (DataRow row4 in cachedRows)
{
if (((row4.Table == column.Table) && ((version2 != DataRowVersion.Original) || (row4.newRecord != row4.oldRecord))) && (((row4 != null) && (row4.RowState != DataRowState.Deleted)) && ((version != DataRowVersion.Original) || (row4.oldRecord != -1))))
{
object obj5 = column.DataExpression.Evaluate(row4, version2);
this.SilentlySetValue(row4, column, version2, obj5);
}
}
}
for (int m = 0; m < this.ParentRelations.Count; m++)
{
DataRelation relation2 = this.ParentRelations[m];
if (relation2.ParentTable == column.Table)
{
foreach (DataRow row3 in row.GetParentRows(relation2, version))
{
if ((((cachedRows == null) || !cachedRows.Contains(row3)) && ((version2 != DataRowVersion.Original) || (row3.newRecord != row3.oldRecord))) && (((row3 != null) && (row3.RowState != DataRowState.Deleted)) && ((version != DataRowVersion.Original) || (row3.oldRecord != -1))))
{
object obj4 = column.DataExpression.Evaluate(row3, version2);
this.SilentlySetValue(row3, column, version2, obj4);
}
}
}
}
for (int n = 0; n < this.ChildRelations.Count; n++)
{
DataRelation relation = this.ChildRelations[n];
if (relation.ChildTable == column.Table)
{
foreach (DataRow row2 in row.GetChildRows(relation, version))
{
if ((((cachedRows == null) || !cachedRows.Contains(row2)) && ((version2 != DataRowVersion.Original) || (row2.newRecord != row2.oldRecord))) && (((row2 != null) && (row2.RowState != DataRowState.Deleted)) && ((version != DataRowVersion.Original) || (row2.oldRecord != -1))))
{
object obj3 = column.DataExpression.Evaluate(row2, version2);
this.SilentlySetValue(row2, column, version2, obj3);
}
}
}
}
}
}
}
}