◆ ReadXmlSchema() [4/5]

void System.Data.DataTable.ReadXmlSchema	(	XmlReader	reader,
		bool	denyResolving )
inlinepackageinherited
Definition at line 5690 of file DataTable.cs.
    {
        long scopeId = DataCommonEventSource.Log.EnterScope("<ds.DataTable.ReadXmlSchema|INFO> {0}, denyResolving={1}", ObjectID, denyResolving);
        try
        {
            DataSet dataSet = new DataSet();
            SerializationFormat remotingFormat = RemotingFormat;
            dataSet.ReadXmlSchema(reader, denyResolving);
            string mainTableName = dataSet.MainTableName;
            if (string.IsNullOrEmpty(_tableName) && string.IsNullOrEmpty(mainTableName))
            {
                return;
            }
            DataTable dataTable = null;
            if (!string.IsNullOrEmpty(_tableName))
            {
                if (!string.IsNullOrEmpty(Namespace))
                {
                    dataTable = dataSet.Tables[_tableName, Namespace];
                }
                else
                {
                    int num = dataSet.Tables.InternalIndexOf(_tableName);
                    if (num > -1)
                    {
                        dataTable = dataSet.Tables[num];
                    }
                }
            }
            else
            {
                string tableNamespace = string.Empty;
                int num2 = mainTableName.IndexOf(':');
                if (num2 > -1)
                {
                    tableNamespace = mainTableName.Substring(0, num2);
                }
                string name = mainTableName.Substring(num2 + 1, mainTableName.Length - num2 - 1);
                dataTable = dataSet.Tables[name, tableNamespace];
            }
            if (dataTable == null)
            {
                string empty = string.Empty;
                empty = (string.IsNullOrEmpty(_tableName) ? mainTableName : ((Namespace.Length > 0) ? (Namespace + ":" + _tableName) : _tableName));
                throw ExceptionBuilder.TableNotFound(empty);
            }
            dataTable._remotingFormat = remotingFormat;
            List<DataTable> list = new List<DataTable>();
            list.Add(dataTable);
            CreateTableList(dataTable, list);
            List<DataRelation> list2 = new List<DataRelation>();
            CreateRelationList(list, list2);
            if (list2.Count == 0)
            {
                if (Columns.Count == 0)
                {
                    DataTable dataTable2 = dataTable;
                    dataTable2.CloneTo(this, null, skipExpressionColumns: false);
                    if (DataSet == null && _tableNamespace == null)
                    {
                        _tableNamespace = dataTable2.Namespace;
                    }
                }
                return;
            }
            if (string.IsNullOrEmpty(TableName))
            {
                TableName = dataTable.TableName;
                if (!string.IsNullOrEmpty(dataTable.Namespace))
                {
                    Namespace = dataTable.Namespace;
                }
            }
            if (DataSet == null)
            {
                DataSet dataSet2 = new DataSet(dataSet.DataSetName);
                dataSet2.SetLocaleValue(dataSet.Locale, dataSet.ShouldSerializeLocale());
                dataSet2.CaseSensitive = dataSet.CaseSensitive;
                dataSet2.Namespace = dataSet.Namespace;
                dataSet2._mainTableName = dataSet._mainTableName;
                dataSet2.RemotingFormat = dataSet.RemotingFormat;
                dataSet2.Tables.Add(this);
            }
            CloneHierarchy(dataTable, DataSet, null);
            foreach (DataTable item in list)
            {
                DataTable dataTable3 = DataSet.Tables[item._tableName, item.Namespace];
                DataTable dataTable4 = dataSet.Tables[item._tableName, item.Namespace];
                foreach (Constraint constraint in dataTable4.Constraints)
                {
                    if (constraint is ForeignKeyConstraint foreignKeyConstraint && foreignKeyConstraint.Table != foreignKeyConstraint.RelatedTable && list.Contains(foreignKeyConstraint.Table) && list.Contains(foreignKeyConstraint.RelatedTable))
                    {
                        ForeignKeyConstraint foreignKeyConstraint2 = (ForeignKeyConstraint)foreignKeyConstraint.Clone(dataTable3.DataSet);
                        if (!dataTable3.Constraints.Contains(foreignKeyConstraint2.ConstraintName))
                        {
                            dataTable3.Constraints.Add(foreignKeyConstraint2);
                        }
                    }
                }
            }
            foreach (DataRelation item2 in list2)
            {
                if (!DataSet.Relations.Contains(item2.RelationName))
                {
                    DataSet.Relations.Add(item2.Clone(DataSet));
                }
            }
            bool flag = false;
            foreach (DataTable item3 in list)
            {
                foreach (DataColumn column in item3.Columns)
                {
                    flag = false;
                    if (column.Expression.Length != 0)
                    {
                        DataColumn[] dependency = column.DataExpression.GetDependency();
                        for (int i = 0; i < dependency.Length; i++)
                        {
                            if (!list.Contains(dependency[i].Table))
                            {
                                flag = true;
                                break;
                            }
                        }
                    }
                    if (!flag)
                    {
                        DataSet.Tables[item3.TableName, item3.Namespace].Columns[column.ColumnName].Expression = column.Expression;
                    }
                }
                flag = false;
            }
        }
        finally
        {
            DataCommonEventSource.Log.ExitScope(scopeId);
        }
    }