◆ LoadSchema() [1/2]

void System.Data.XSDSchema.LoadSchema	(	XmlSchemaSet	schemaSet,
		DataSet	ds )
inline
Definition at line 600 of file XSDSchema.cs.
    {
        _constraintNodes = new Hashtable();
        _refTables = new ArrayList();
        _columnExpressions = new ArrayList();
        _complexTypes = new ArrayList();
        bool flag = false;
        bool isNewDataSet = ds.Tables.Count == 0;
        if (schemaSet == null)
        {
            return;
        }
        _schemaSet = schemaSet;
        _ds = ds;
        ds._fIsSchemaLoading = true;
        IEnumerator enumerator = schemaSet.Schemas().GetEnumerator();
        try
        {
            if (enumerator.MoveNext())
            {
                XmlSchema xmlSchema = (XmlSchema)enumerator.Current;
                _schemaName = xmlSchema.Id;
                if (_schemaName == null || _schemaName.Length == 0)
                {
                    _schemaName = "NewDataSet";
                }
                ds.DataSetName = XmlConvert.DecodeName(_schemaName);
                string targetNamespace = xmlSchema.TargetNamespace;
                if (ds._namespaceURI == null || ds._namespaceURI.Length == 0)
                {
                    ds._namespaceURI = ((targetNamespace == null) ? string.Empty : targetNamespace);
                }
            }
        }
        finally
        {
            IDisposable disposable = enumerator as IDisposable;
            if (disposable != null)
            {
                disposable.Dispose();
            }
        }
        _annotations = new XmlSchemaObjectCollection();
        _elements = new XmlSchemaObjectCollection();
        _elementsTable = new Hashtable();
        _attributes = new Hashtable();
        _attributeGroups = new Hashtable();
        _schemaTypes = new Hashtable();
        _tableDictionary = new Dictionary<DataTable, List<DataTable>>();
        _existingSimpleTypeMap = new Hashtable();
        foreach (DataTable table in ds.Tables)
        {
            foreach (DataColumn column in table.Columns)
            {
                if (column.SimpleType != null && column.SimpleType.Name != null && column.SimpleType.Name.Length != 0)
                {
                    _existingSimpleTypeMap[column.SimpleType.SimpleTypeQualifiedName] = column;
                }
            }
        }
        foreach (XmlSchema item in schemaSet.Schemas())
        {
            CollectElementsAnnotations(item);
        }
        _dsElement = FindDatasetElement(_elements);
        if (_dsElement != null)
        {
            string stringAttribute = GetStringAttribute(_dsElement, "MainDataTable", "");
            if (stringAttribute != null)
            {
                ds.MainTableName = XmlConvert.DecodeName(stringAttribute);
            }
        }
        else
        {
            if (FromInference)
            {
                ds._fTopLevelTable = true;
            }
            flag = true;
        }
        List<XmlQualifiedName> list = new List<XmlQualifiedName>();
        if (ds != null && ds._useDataSetSchemaOnly)
        {
            int num = DatasetElementCount(_elements);
            if (num == 0)
            {
                throw ExceptionBuilder.IsDataSetAttributeMissingInSchema();
            }
            if (num > 1)
            {
                throw ExceptionBuilder.TooManyIsDataSetAttributesInSchema();
            }
            XmlSchemaComplexType xmlSchemaComplexType = (XmlSchemaComplexType)FindTypeNode(_dsElement);
            if (xmlSchemaComplexType.Particle != null)
            {
                XmlSchemaObjectCollection particleItems = GetParticleItems(xmlSchemaComplexType.Particle);
                if (particleItems != null)
                {
                    foreach (XmlSchemaAnnotated item2 in particleItems)
                    {
                        if (item2 is XmlSchemaElement xmlSchemaElement && xmlSchemaElement.RefName.Name.Length != 0)
                        {
                            list.Add(xmlSchemaElement.QualifiedName);
                        }
                    }
                }
            }
        }
        foreach (XmlSchemaElement element in _elements)
        {
            if (element != _dsElement && (ds == null || !ds._useDataSetSchemaOnly || _dsElement == null || _dsElement.Parent == element.Parent || list.Contains(element.QualifiedName)))
            {
                string instanceName = GetInstanceName(element);
                if (_refTables.Contains(element.QualifiedName.Namespace + ":" + instanceName))
                {
                    HandleRefTableProperties(_refTables, element);
                }
                else
                {
                    HandleTable(element);
                }
            }
        }
        if (_dsElement != null)
        {
            HandleDataSet(_dsElement, isNewDataSet);
        }
        foreach (XmlSchemaAnnotation annotation in _annotations)
        {
            HandleRelations(annotation, fNested: false);
        }
        for (int i = 0; i < _columnExpressions.Count; i++)
        {
            DataColumn dataColumn2 = (DataColumn)_columnExpressions[i];
            dataColumn2.Expression = (string)_expressions[dataColumn2];
        }
        foreach (DataTable table2 in ds.Tables)
        {
            if (table2.NestedParentRelations.Length != 0 || !(table2.Namespace == ds.Namespace))
            {
                continue;
            }
            DataRelationCollection childRelations = table2.ChildRelations;
            for (int j = 0; j < childRelations.Count; j++)
            {
                if (childRelations[j].Nested && table2.Namespace == childRelations[j].ChildTable.Namespace)
                {
                    childRelations[j].ChildTable._tableNamespace = null;
                }
            }
            table2._tableNamespace = null;
        }
        DataTable dataTable3 = ds.Tables[ds.DataSetName, ds.Namespace];
        if (dataTable3 != null)
        {
            dataTable3._fNestedInDataset = true;
        }
        if (FromInference && ds.Tables.Count == 0 && string.Equals(ds.DataSetName, "NewDataSet", StringComparison.Ordinal))
        {
            ds.DataSetName = XmlConvert.DecodeName(((XmlSchemaElement)_elements[0]).Name);
        }
        ds._fIsSchemaLoading = false;
        if (!flag)
        {
            return;
        }
        if (ds.Tables.Count > 0)
        {
            ds.Namespace = ds.Tables[0].Namespace;
            ds.Prefix = ds.Tables[0].Prefix;
            return;
        }
        foreach (XmlSchema item3 in schemaSet.Schemas())
        {
            ds.Namespace = item3.TargetNamespace;
        }
    }