EvaluateDependentExpressions() [2/2]

void System.Data.DataTable.EvaluateDependentExpressions ( List< DataColumn > columns, DataRow row, DataRowVersion version, List< DataRow > cachedRows )

inlinepackageinherited

Definition at line 6136 of file DataTable.cs.

    {
        if (columns == null)
        {
            return;
        }
        int count = columns.Count;
        for (int i = 0; i < count; i++)
        {
            if (columns[i].Table != this)
            {
                continue;
            }
            DataColumn dataColumn = columns[i];
            if (dataColumn.DataExpression != null && dataColumn.DataExpression.HasLocalAggregate())
            {
                DataRowVersion dataRowVersion = ((version == DataRowVersion.Proposed) ? DataRowVersion.Default : version);
                bool flag = dataColumn.DataExpression.IsTableAggregate();
                object newValue = null;
                if (flag)
                {
                    newValue = dataColumn.DataExpression.Evaluate(row, dataRowVersion);
                }
                for (int j = 0; j < Rows.Count; j++)
                {
                    DataRow dataRow = Rows[j];
                    if (dataRow.RowState != DataRowState.Deleted && (dataRowVersion != DataRowVersion.Original || (dataRow._oldRecord != -1 && dataRow._oldRecord != dataRow._newRecord)))
                    {
                        if (!flag)
                        {
                            newValue = dataColumn.DataExpression.Evaluate(dataRow, dataRowVersion);
                        }
                        SilentlySetValue(dataRow, dataColumn, dataRowVersion, newValue);
                    }
                }
            }
            else if (row.RowState != DataRowState.Deleted && (version != DataRowVersion.Original || (row._oldRecord != -1 && row._oldRecord != row._newRecord)))
            {
                SilentlySetValue(row, dataColumn, version, (dataColumn.DataExpression == null) ? dataColumn.DefaultValue : dataColumn.DataExpression.Evaluate(row, version));
            }
        }
        count = columns.Count;
        for (int k = 0; k < count; k++)
        {
            DataColumn dataColumn2 = columns[k];
            if (dataColumn2.Table == this && (dataColumn2.DataExpression == null || dataColumn2.DataExpression.HasLocalAggregate()))
            {
                continue;
            }
            DataRowVersion dataRowVersion2 = ((version == DataRowVersion.Proposed) ? DataRowVersion.Default : version);
            if (cachedRows != null)
            {
                foreach (DataRow cachedRow in cachedRows)
                {
                    if (cachedRow.Table == dataColumn2.Table && (dataRowVersion2 != DataRowVersion.Original || cachedRow._newRecord != cachedRow._oldRecord) && cachedRow != null && cachedRow.RowState != DataRowState.Deleted && (version != DataRowVersion.Original || cachedRow._oldRecord != -1))
                    {
                        object newValue2 = dataColumn2.DataExpression.Evaluate(cachedRow, dataRowVersion2);
                        SilentlySetValue(cachedRow, dataColumn2, dataRowVersion2, newValue2);
                    }
                }
            }
            for (int l = 0; l < ParentRelations.Count; l++)
            {
                DataRelation dataRelation = ParentRelations[l];
                if (dataRelation.ParentTable != dataColumn2.Table)
                {
                    continue;
                }
                DataRow[] parentRows = row.GetParentRows(dataRelation, version);
                foreach (DataRow dataRow2 in parentRows)
                {
                    if ((cachedRows == null || !cachedRows.Contains(dataRow2)) && (dataRowVersion2 != DataRowVersion.Original || dataRow2._newRecord != dataRow2._oldRecord) && dataRow2 != null && dataRow2.RowState != DataRowState.Deleted && (version != DataRowVersion.Original || dataRow2._oldRecord != -1))
                    {
                        object newValue3 = dataColumn2.DataExpression.Evaluate(dataRow2, dataRowVersion2);
                        SilentlySetValue(dataRow2, dataColumn2, dataRowVersion2, newValue3);
                    }
                }
            }
            for (int n = 0; n < ChildRelations.Count; n++)
            {
                DataRelation dataRelation2 = ChildRelations[n];
                if (dataRelation2.ChildTable != dataColumn2.Table)
                {
                    continue;
                }
                DataRow[] childRows = row.GetChildRows(dataRelation2, version);
                foreach (DataRow dataRow3 in childRows)
                {
                    if ((cachedRows == null || !cachedRows.Contains(dataRow3)) && (dataRowVersion2 != DataRowVersion.Original || dataRow3._newRecord != dataRow3._oldRecord) && dataRow3 != null && dataRow3.RowState != DataRowState.Deleted && (version != DataRowVersion.Original || dataRow3._oldRecord != -1))
                    {
                        object newValue4 = dataColumn2.DataExpression.Evaluate(dataRow3, dataRowVersion2);
                        SilentlySetValue(dataRow3, dataColumn2, dataRowVersion2, newValue4);
                    }
                }
            }
        }
    }

References System.Data.DataTable.ChildRelations, System.Collections.Generic.Dictionary< TKey, TValue >.Contains(), System.Data.DataRowCollection.Count, System.Data.InternalDataCollectionBase.Count, System.count, System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.Runtime.Serialization.Dictionary, System.Data.DataTable.ParentRelations, System.Data.DataTable.Rows, and System.Data.DataTable.SilentlySetValue().