System.Data.DataTable.EvaluateExpressions C# (CSharp) Méthode

        internal void EvaluateExpressions(DataColumn column)
        {
            // evaluates all rows for expression from specified column
            Debug.Assert(column.Computed, "Only computed columns should be re-evaluated.");
            int count = column._table.Rows.Count;
            if (column.DataExpression.IsTableAggregate() && count > 0)
            {
                // this value is a constant across the table.
                object aggCurrent = column.DataExpression.Evaluate();
                for (int j = 0; j < count; j++)
                {
                    DataRow row = column._table.Rows[j];
                    // only evaluate original values if different from current.
                    if (row._oldRecord != -1 && row._oldRecord != row._newRecord)
                    {
                        column[row._oldRecord] = aggCurrent;
                    }
                    if (row._newRecord != -1)
                    {
                        column[row._newRecord] = aggCurrent;
                    }
                    if (row._tempRecord != -1)
                    {
                        column[row._tempRecord] = aggCurrent;
                    }
                }
            }
            else
            {
                for (int j = 0; j < count; j++)
                {
                    DataRow row = column._table.Rows[j];

                    if (row._oldRecord != -1 && row._oldRecord != row._newRecord)
                    {
                        column[row._oldRecord] = column.DataExpression.Evaluate(row, DataRowVersion.Original);
                    }
                    if (row._newRecord != -1)
                    {
                        column[row._newRecord] = column.DataExpression.Evaluate(row, DataRowVersion.Current);
                    }
                    if (row._tempRecord != -1)
                    {
                        column[row._tempRecord] = column.DataExpression.Evaluate(row, DataRowVersion.Proposed);
                    }
                }
            }

            column.Table.ResetInternalIndexes(column);
            EvaluateDependentExpressions(column);
        }

        internal void MergeTable(DataTable src)
        {
            bool enforceConstraints = false;

            if (!this.isStandAlonetable)
            {
                if (src.DataSet == this.dataSet)
                {
                    return;
                }
                enforceConstraints = this.dataSet.EnforceConstraints;
                this.dataSet.EnforceConstraints = false;
            }
            else
            {
                if (src == this.dataTable)
                {
                    return;
                }
                this.dataTable.SuspendEnforceConstraints = true;
            }
            if (this.dataSet != null)
            {
                if ((src.DataSet == null) || (src.DataSet.namespaceURI != this.dataSet.namespaceURI))
                {
                    this._IgnoreNSforTableLookup = true;
                }
            }
            else if (((this.dataTable.DataSet == null) || (src.DataSet == null)) || (src.DataSet.namespaceURI != this.dataTable.DataSet.namespaceURI))
            {
                this._IgnoreNSforTableLookup = true;
            }
            this.MergeTableData(src);
            DataTable dataTable = this.dataTable;

            if ((dataTable == null) && (this.dataSet != null))
            {
                if (this._IgnoreNSforTableLookup)
                {
                    dataTable = this.dataSet.Tables[src.TableName];
                }
                else
                {
                    dataTable = this.dataSet.Tables[src.TableName, src.Namespace];
                }
            }
            if (dataTable != null)
            {
                dataTable.EvaluateExpressions();
            }
            if (!this.isStandAlonetable)
            {
                this.dataSet.EnforceConstraints = enforceConstraints;
            }
            else
            {
                this.dataTable.SuspendEnforceConstraints = false;
                try
                {
                    if (this.dataTable.EnforceConstraints)
                    {
                        this.dataTable.EnableConstraints();
                    }
                }
                catch (ConstraintException)
                {
                    if (this.dataTable.DataSet != null)
                    {
                        this.dataTable.DataSet.EnforceConstraints = false;
                    }
                    throw;
                }
            }
        }