EvaluateExpressions() private method

private EvaluateExpressions ( ) : void
return void
        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;
                }
            }
        }
Example #2
0
        internal void MergeTable(DataTable src)
        {
            bool fEnforce = false;

            if (!isStandAlonetable)
            {
                if (src.DataSet == dataSet)
                {
                    return;                         //somebody is doing an 'automerge'
                }
                fEnforce = dataSet.EnforceConstraints;
                dataSet.EnforceConstraints = false;
            }
            else
            {
                if (src == dataTable)
                {
                    return;                   //somebody is doing an 'automerge'
                }
                dataTable.SuspendEnforceConstraints = true;
            }

            if (this.dataSet != null)   // this is ds.Merge
            // if source does not have a DS, or if NS of both DS does not match, ignore the NS
            {
                if (src.DataSet == null || src.DataSet.namespaceURI != this.dataSet.namespaceURI)
                {
                    _IgnoreNSforTableLookup = true;
                }
            }
            else   // this is dt.Merge
            {
                if (this.dataTable.DataSet == null || src.DataSet == null ||
                    src.DataSet.namespaceURI != this.dataTable.DataSet.namespaceURI)
                {
                    _IgnoreNSforTableLookup = true;
                }
            }

            MergeTableData(src);

            DataTable dt = dataTable;

            if (dt == null && dataSet != null)
            {
                if (_IgnoreNSforTableLookup)
                {
                    dt = dataSet.Tables[src.TableName];
                }
                else
                {
                    dt = dataSet.Tables[src.TableName, src.Namespace];
                }
            }

            if (dt != null)
            {
                dt.EvaluateExpressions();
            }

            if (!isStandAlonetable)
            {
                dataSet.EnforceConstraints = fEnforce;
            }
            else
            {
                dataTable.SuspendEnforceConstraints = false;
                try {
                    if (dataTable.EnforceConstraints)
                    {
                        dataTable.EnableConstraints();
                    }
                }
                catch (ConstraintException) {
                    if (dataTable.DataSet != null)
                    {
                        dataTable.DataSet.EnforceConstraints = false;
                    }
                    throw;
                }
            }
        }