XmlTreeGen.cs

Go to the documentation of this file.

using System.Collections;
using System.ComponentModel;
using System.Data.Common;
using System.Data.SqlTypes;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Numerics;
using System.Text;
using System.Xml;
 
namespace System.Data;
 
internal sealed class XmlTreeGen
{
    private ArrayList _constraintNames;
 
    private Hashtable _namespaces;
 
    private Hashtable _autogenerated;
 
    private Hashtable _prefixes;
 
    private DataSet _ds;
 
    private readonly ArrayList _tables = new ArrayList();
 
    private readonly ArrayList _relations = new ArrayList();
 
    private XmlDocument _dc;
 
    private XmlElement _sRoot;
 
    private int _prefixCount;
 
    private readonly SchemaFormat _schFormat = SchemaFormat.Public;
 
    private string _filePath;
 
    private string _fileName;
 
    private string _fileExt;
 
    private XmlElement _dsElement;
 
    private XmlElement _constraintSeparator;
 
    private Converter<Type, string> _targetConverter;
 
    internal XmlTreeGen(SchemaFormat format)
    {
        _schFormat = format;
    }
 
    internal static void AddExtendedProperties(PropertyCollection props, XmlElement node)
    {
        AddExtendedProperties(props, node, null);
    }
 
    internal static void AddExtendedProperties(PropertyCollection props, XmlElement node, Type type)
    {
        if (props == null)
        {
            return;
        }
        foreach (DictionaryEntry prop in props)
        {
            string text = ((!(prop.Key is INullable)) ? Convert.ToString(prop.Key, CultureInfo.InvariantCulture) : ((string)SqlConvert.ChangeTypeForXML(prop.Key, typeof(string))));
            string value = ((prop.Value is INullable) ? ((string)SqlConvert.ChangeTypeForXML(prop.Value, typeof(string))) : ((!(prop.Value is BigInteger)) ? Convert.ToString(prop.Value, CultureInfo.InvariantCulture) : ((string)BigIntegerStorage.ConvertFromBigInteger((BigInteger)prop.Value, typeof(string), CultureInfo.InvariantCulture))));
            if (type == typeof(DataRelation))
            {
                text = "rel_" + text;
            }
            else if (type == typeof(ForeignKeyConstraint))
            {
                text = "fk_" + text;
            }
            node.SetAttribute(XmlConvert.EncodeLocalName(text), "urn:schemas-microsoft-com:xml-msprop", value);
        }
    }
 
    [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
    internal void AddXdoProperties(object instance, XmlElement root, XmlDocument xd)
    {
        if (instance == null)
        {
            return;
        }
        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(instance);
        if (instance is DataSet || instance is DataTable || instance is DataColumn || instance is DataRelation)
        {
            for (int i = 0; i < properties.Count; i++)
            {
                AddXdoProperty(properties[i], instance, root, xd);
            }
        }
    }
 
    [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
    internal void AddXdoProperty(PropertyDescriptor pd, object instance, XmlElement root, XmlDocument xd)
    {
        Type propertyType = pd.PropertyType;
        bool flag = false;
        DataColumn dataColumn = null;
        bool flag2 = false;
        bool flag3 = false;
        if (instance is DataColumn)
        {
            dataColumn = (DataColumn)instance;
            flag = true;
            flag2 = dataColumn.IsSqlType;
            flag3 = dataColumn.ImplementsINullable;
        }
        if ((!flag3 && propertyType != typeof(string) && propertyType != typeof(bool) && propertyType != typeof(Type) && propertyType != typeof(object) && propertyType != typeof(CultureInfo) && propertyType != typeof(long) && propertyType != typeof(int)) || ((!pd.ShouldSerializeValue(instance) || !ContainsDesignerSerializationVisibleAttribute(pd)) && !flag2))
        {
            return;
        }
        object value = pd.GetValue(instance);
        if (value is InternalDataCollectionBase || value is PropertyCollection || string.Equals(pd.Name, "Namespace", StringComparison.Ordinal) || string.Equals(pd.Name, "PrimaryKey", StringComparison.Ordinal) || string.Equals(pd.Name, "ColumnName", StringComparison.Ordinal) || string.Equals(pd.Name, "DefaultValue", StringComparison.Ordinal) || string.Equals(pd.Name, "TableName", StringComparison.Ordinal) || string.Equals(pd.Name, "DataSetName", StringComparison.Ordinal) || string.Equals(pd.Name, "AllowDBNull", StringComparison.Ordinal) || string.Equals(pd.Name, "Unique", StringComparison.Ordinal) || string.Equals(pd.Name, "NestedInDataSet", StringComparison.Ordinal) || string.Equals(pd.Name, "Locale", StringComparison.Ordinal) || string.Equals(pd.Name, "CaseSensitive", StringComparison.Ordinal) || string.Equals(pd.Name, "RemotingFormat", StringComparison.Ordinal))
        {
            return;
        }
        if (flag)
        {
            if (string.Equals(pd.Name, "DataType", StringComparison.Ordinal))
            {
                string text = XmlDataTypeName(dataColumn.DataType);
                if (flag2 || dataColumn.DataType == typeof(BigInteger))
                {
                    root.SetAttribute("DataType", "urn:schemas-microsoft-com:xml-msdata", dataColumn.DataType.FullName);
                }
                else if (text.Length == 0 || flag3 || (text == "anyType" && dataColumn.XmlDataType != "anyType") || dataColumn.DataType == typeof(DateTimeOffset))
                {
                    SetMSDataAttribute(root, dataColumn.DataType);
                }
                return;
            }
            if (string.Equals(pd.Name, "Attribute", StringComparison.Ordinal))
            {
                return;
            }
        }
        string value2 = pd.Converter.ConvertToString(value);
        root.SetAttribute(pd.Name, "urn:schemas-microsoft-com:xml-msdata", value2);
    }
 
    [DynamicDependency(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor | DynamicallyAccessedMemberTypes.PublicFields, typeof(DesignerSerializationVisibilityAttribute))]
    [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "The DynamicDependency ensures the correct members are preserved.")]
    private bool ContainsDesignerSerializationVisibleAttribute(PropertyDescriptor pd)
    {
        return pd.Attributes.Contains(DesignerSerializationVisibilityAttribute.Visible);
    }
 
    internal static string XmlDataTypeName(Type type)
    {
        if (type == typeof(char))
        {
            return "_";
        }
        if (type == typeof(byte[]) || type == typeof(SqlBytes))
        {
            return "base64Binary";
        }
        if (type == typeof(DateTime) || type == typeof(SqlDateTime))
        {
            return "dateTime";
        }
        if (type == typeof(TimeSpan))
        {
            return "duration";
        }
        if (type == typeof(decimal) || type == typeof(SqlDecimal) || type == typeof(SqlMoney))
        {
            return "decimal";
        }
        if (type == typeof(int))
        {
            return "int";
        }
        if (type == typeof(bool) || type == typeof(SqlBoolean))
        {
            return "boolean";
        }
        if (type == typeof(float) || type == typeof(SqlSingle))
        {
            return "float";
        }
        if (type == typeof(double) || type == typeof(SqlDouble))
        {
            return "double";
        }
        if (type == typeof(sbyte) || type == typeof(SqlByte))
        {
            return "byte";
        }
        if (type == typeof(byte))
        {
            return "unsignedByte";
        }
        if (type == typeof(short) || type == typeof(SqlInt16))
        {
            return "short";
        }
        if (type == typeof(int) || type == typeof(SqlInt32))
        {
            return "int";
        }
        if (type == typeof(long) || type == typeof(SqlInt64))
        {
            return "long";
        }
        if (type == typeof(ushort))
        {
            return "unsignedShort";
        }
        if (type == typeof(uint))
        {
            return "unsignedInt";
        }
        if (type == typeof(ulong))
        {
            return "unsignedLong";
        }
        if (type == typeof(BigInteger))
        {
            return "anyType";
        }
        if (type == typeof(Uri))
        {
            return "anyURI";
        }
        if (type == typeof(SqlBinary))
        {
            return "hexBinary";
        }
        if (type == typeof(string) || type == typeof(SqlGuid) || type == typeof(SqlString) || type == typeof(SqlChars))
        {
            return "string";
        }
        if (type == typeof(object) || type == typeof(SqlXml) || type == typeof(DateTimeOffset))
        {
            return "anyType";
        }
        return string.Empty;
    }
 
    private void GenerateConstraintNames(DataTable table, bool fromTable)
    {
        StringBuilder stringBuilder = null;
        foreach (Constraint constraint in table.Constraints)
        {
            if (fromTable && constraint is ForeignKeyConstraint && !_tables.Contains(((ForeignKeyConstraint)constraint).RelatedTable))
            {
                continue;
            }
            int num = 0;
            string text = constraint.ConstraintName;
            while (_constraintNames.Contains(text))
            {
                if (stringBuilder == null)
                {
                    stringBuilder = new StringBuilder();
                }
                stringBuilder.Append(table.TableName).Append('_').Append(constraint.ConstraintName);
                if (0 < num)
                {
                    stringBuilder.Append('_').Append(num);
                }
                num++;
                text = stringBuilder.ToString();
                stringBuilder.Length = 0;
            }
            _constraintNames.Add(text);
            constraint.SchemaName = text;
        }
    }
 
    private void GenerateConstraintNames(ArrayList tables)
    {
        for (int i = 0; i < tables.Count; i++)
        {
            GenerateConstraintNames((DataTable)tables[i], fromTable: true);
        }
    }
 
    private void GenerateConstraintNames(DataSet ds)
    {
        foreach (DataTable table in ds.Tables)
        {
            GenerateConstraintNames(table, fromTable: false);
        }
    }
 
    private static bool _PropsNotEmpty(PropertyCollection props)
    {
        if (props != null)
        {
            return props.Count != 0;
        }
        return false;
    }
 
    private bool HaveExtendedProperties(DataSet ds)
    {
        if (_PropsNotEmpty(ds._extendedProperties))
        {
            return true;
        }
        for (int i = 0; i < ds.Tables.Count; i++)
        {
            DataTable dataTable = ds.Tables[i];
            if (_PropsNotEmpty(dataTable._extendedProperties))
            {
                return true;
            }
            for (int j = 0; j < dataTable.Columns.Count; j++)
            {
                if (_PropsNotEmpty(dataTable.Columns[j]._extendedProperties))
                {
                    return true;
                }
            }
        }
        for (int k = 0; k < ds.Relations.Count; k++)
        {
            if (_PropsNotEmpty(ds.Relations[k]._extendedProperties))
            {
                return true;
            }
        }
        return false;
    }
 
    internal void WriteSchemaRoot(XmlDocument xd, XmlElement rootSchema, string targetNamespace)
    {
        if (!string.IsNullOrEmpty(targetNamespace))
        {
            rootSchema.SetAttribute("targetNamespace", targetNamespace);
            rootSchema.SetAttribute("xmlns:mstns", targetNamespace);
        }
        rootSchema.SetAttribute("xmlns", targetNamespace);
        rootSchema.SetAttribute("xmlns:xs", "http://www.w3.org/2001/XMLSchema");
        rootSchema.SetAttribute("xmlns:msdata", "urn:schemas-microsoft-com:xml-msdata");
        if (_ds != null && HaveExtendedProperties(_ds))
        {
            rootSchema.SetAttribute("xmlns:msprop", "urn:schemas-microsoft-com:xml-msprop");
        }
        if (!string.IsNullOrEmpty(targetNamespace))
        {
            rootSchema.SetAttribute("attributeFormDefault", "qualified");
            rootSchema.SetAttribute("elementFormDefault", "qualified");
        }
    }
 
    internal static void ValidateColumnMapping(Type columnType)
    {
        if (DataStorage.IsTypeCustomType(columnType))
        {
            throw ExceptionBuilder.InvalidDataColumnMapping(columnType);
        }
    }
 
    internal void SetupAutoGenerated(DataSet ds)
    {
        foreach (DataTable table in ds.Tables)
        {
            SetupAutoGenerated(table);
        }
    }
 
    internal void SetupAutoGenerated(ArrayList dt)
    {
        for (int i = 0; i < dt.Count; i++)
        {
            SetupAutoGenerated((DataTable)dt[i]);
        }
    }
 
    internal void SetupAutoGenerated(DataTable dt)
    {
        foreach (DataColumn column in dt.Columns)
        {
            if (AutoGenerated(column))
            {
                _autogenerated[column] = column;
            }
        }
        foreach (Constraint constraint in dt.Constraints)
        {
            if (constraint is ForeignKeyConstraint foreignKeyConstraint)
            {
                if (AutoGenerated(foreignKeyConstraint))
                {
                    _autogenerated[foreignKeyConstraint] = foreignKeyConstraint;
                    continue;
                }
                if (_autogenerated[foreignKeyConstraint.Columns[0]] != null)
                {
                    _autogenerated[foreignKeyConstraint.Columns[0]] = null;
                }
                if (_autogenerated[foreignKeyConstraint.RelatedColumnsReference[0]] != null)
                {
                    _autogenerated[foreignKeyConstraint.RelatedColumnsReference[0]] = null;
                }
                UniqueConstraint uniqueConstraint = (UniqueConstraint)foreignKeyConstraint.RelatedTable.Constraints.FindConstraint(new UniqueConstraint("TEMP", foreignKeyConstraint.RelatedColumnsReference));
                if (uniqueConstraint != null)
                {
                    if (_autogenerated[uniqueConstraint] != null)
                    {
                        _autogenerated[uniqueConstraint] = null;
                    }
                    if (_autogenerated[uniqueConstraint.Key.ColumnsReference[0]] != null)
                    {
                        _autogenerated[uniqueConstraint.Key.ColumnsReference[0]] = null;
                    }
                }
            }
            else
            {
                UniqueConstraint uniqueConstraint2 = (UniqueConstraint)constraint;
                if (AutoGenerated(uniqueConstraint2))
                {
                    _autogenerated[uniqueConstraint2] = uniqueConstraint2;
                }
                else if (_autogenerated[uniqueConstraint2.Key.ColumnsReference[0]] != null)
                {
                    _autogenerated[uniqueConstraint2.Key.ColumnsReference[0]] = null;
                }
            }
        }
    }
 
    private void CreateTablesHierarchy(DataTable dt)
    {
        foreach (DataRelation childRelation in dt.ChildRelations)
        {
            if (!_tables.Contains(childRelation.ChildTable))
            {
                _tables.Add(childRelation.ChildTable);
                CreateTablesHierarchy(childRelation.ChildTable);
            }
        }
    }
 
    private void CreateRelations(DataTable dt)
    {
        foreach (DataRelation childRelation in dt.ChildRelations)
        {
            if (!_relations.Contains(childRelation))
            {
                _relations.Add(childRelation);
                CreateRelations(childRelation.ChildTable);
            }
        }
    }
 
    private DataTable[] CreateToplevelTables()
    {
        ArrayList arrayList = new ArrayList();
        for (int i = 0; i < _tables.Count; i++)
        {
            DataTable dataTable = (DataTable)_tables[i];
            if (dataTable.ParentRelations.Count == 0)
            {
                arrayList.Add(dataTable);
                continue;
            }
            bool flag = false;
            for (int j = 0; j < dataTable.ParentRelations.Count; j++)
            {
                if (dataTable.ParentRelations[j].Nested)
                {
                    if (dataTable.ParentRelations[j].ParentTable == dataTable)
                    {
                        flag = false;
                        break;
                    }
                    flag = true;
                }
            }
            if (!flag)
            {
                arrayList.Add(dataTable);
            }
        }
        if (arrayList.Count == 0)
        {
            return Array.Empty<DataTable>();
        }
        DataTable[] array = new DataTable[arrayList.Count];
        arrayList.CopyTo(array, 0);
        return array;
    }
 
    [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
    internal void SchemaTree(XmlDocument xd, XmlWriter xmlWriter, DataSet ds, DataTable dt, bool writeHierarchy)
    {
        _constraintNames = new ArrayList();
        _autogenerated = new Hashtable();
        bool flag = _filePath != null;
        _dsElement = xd.CreateElement("xs", "element", "http://www.w3.org/2001/XMLSchema");
        bool flag2 = false;
        if (ds != null)
        {
            _ds = ds;
            foreach (DataTable table in ds.Tables)
            {
                _tables.Add(table);
            }
        }
        else
        {
            if (dt.DataSet != null)
            {
                _ds = dt.DataSet;
            }
            _tables.Add(dt);
            if (writeHierarchy)
            {
                CreateTablesHierarchy(dt);
            }
        }
        _dc = xd;
        _namespaces = new Hashtable();
        _prefixes = new Hashtable();
        XmlElement xmlElement = (_sRoot = xd.CreateElement("xs", "schema", "http://www.w3.org/2001/XMLSchema"));
        if (_ds != null)
        {
            xmlElement.SetAttribute("id", XmlConvert.EncodeLocalName(_ds.DataSetName));
        }
        else
        {
            xmlElement.SetAttribute("id", XmlConvert.EncodeLocalName("NewDataSet"));
        }
        if (_ds != null)
        {
            WriteSchemaRoot(xd, xmlElement, _ds.Namespace);
        }
        else
        {
            WriteSchemaRoot(xd, xmlElement, dt.Namespace);
        }
        if (_schFormat == SchemaFormat.Remoting)
        {
            if (_ds != null)
            {
                _namespaces[_ds.Namespace] = xmlElement;
            }
            else
            {
                _namespaces[dt.Namespace] = xmlElement;
            }
        }
        if (_schFormat != SchemaFormat.Remoting && _ds != null)
        {
            _namespaces[_ds.Namespace] = xmlElement;
            if (_ds.Namespace.Length == 0)
            {
                _prefixes[_ds.Namespace] = null;
            }
            else
            {
                xmlElement.SetAttribute("xmlns:mstns", _ds.Namespace);
                _prefixes[_ds.Namespace] = "mstns";
            }
        }
        if (ds != null)
        {
            GenerateConstraintNames(ds);
        }
        else
        {
            GenerateConstraintNames(_tables);
        }
        if (_schFormat != SchemaFormat.Remoting)
        {
            if (ds != null)
            {
                SetupAutoGenerated(ds);
            }
            else
            {
                SetupAutoGenerated(_tables);
            }
        }
        DataTable[] array = ((ds != null) ? ds.TopLevelTables(forSchema: true) : CreateToplevelTables());
        if (array.Length == 0 || _schFormat == SchemaFormat.WebServiceSkipSchema || _schFormat == SchemaFormat.RemotingSkipSchema)
        {
            FillDataSetElement(xd, ds, dt);
            xmlElement.AppendChild(_dsElement);
            AddXdoProperties(_ds, _dsElement, xd);
            AddExtendedProperties(ds._extendedProperties, _dsElement);
            xd.AppendChild(xmlElement);
            xd.Save(xmlWriter);
            xmlWriter.Flush();
            return;
        }
        XmlElement xmlElement2 = FillDataSetElement(xd, ds, dt);
        _constraintSeparator = xd.CreateElement("xs", "SHOULDNOTBEHERE", "http://www.w3.org/2001/XMLSchema");
        _dsElement.AppendChild(_constraintSeparator);
        if (_ds != null)
        {
            AddXdoProperties(_ds, _dsElement, xd);
            AddExtendedProperties(_ds._extendedProperties, _dsElement);
        }
        for (int i = 0; i < array.Length; i++)
        {
            XmlElement xmlElement3 = HandleTable(array[i], xd, xmlElement);
            if ((_ds != null && _ds.Namespace == array[i].Namespace) || string.IsNullOrEmpty(array[i].Namespace) || _schFormat == SchemaFormat.Remoting)
            {
                bool flag3 = array[i]._fNestedInDataset;
                if (_ds != null && _ds.Namespace.Length != 0 && string.IsNullOrEmpty(array[i].Namespace))
                {
                    flag3 = true;
                }
                if (array[i].SelfNested)
                {
                    flag3 = false;
                }
                if (array[i].NestedParentsCount > 1)
                {
                    flag3 = false;
                }
                if (flag3)
                {
                    if (array[i].MinOccurs != 1m)
                    {
                        xmlElement3.SetAttribute("minOccurs", array[i].MinOccurs.ToString(CultureInfo.InvariantCulture));
                    }
                    if (array[i].MaxOccurs == -1m)
                    {
                        xmlElement3.SetAttribute("maxOccurs", "unbounded");
                    }
                    else if (array[i].MaxOccurs != 1m)
                    {
                        xmlElement3.SetAttribute("maxOccurs", array[i].MaxOccurs.ToString(CultureInfo.InvariantCulture));
                    }
                }
                if (!flag3)
                {
                    xmlElement.AppendChild(xmlElement3);
                    XmlElement xmlElement4 = xd.CreateElement("xs", "element", "http://www.w3.org/2001/XMLSchema");
                    if ((_ds != null && _ds.Namespace == array[i].Namespace) || string.IsNullOrEmpty(array[i].Namespace) || _schFormat == SchemaFormat.Remoting)
                    {
                        xmlElement4.SetAttribute("ref", array[i].EncodedTableName);
                    }
                    else
                    {
                        xmlElement4.SetAttribute("ref", (string)_prefixes[array[i].Namespace] + ":" + array[i].EncodedTableName);
                    }
                    xmlElement2.AppendChild(xmlElement4);
                }
                else
                {
                    xmlElement2.AppendChild(xmlElement3);
                }
            }
            else
            {
                AppendChildWithoutRef(xmlElement, array[i].Namespace, xmlElement3, "element");
                XmlElement xmlElement5 = xd.CreateElement("xs", "element", "http://www.w3.org/2001/XMLSchema");
                xmlElement5.SetAttribute("ref", (string)_prefixes[array[i].Namespace] + ":" + array[i].EncodedTableName);
                xmlElement2.AppendChild(xmlElement5);
            }
        }
        _dsElement.RemoveChild(_constraintSeparator);
        xmlElement.AppendChild(_dsElement);
        DataRelation[] array2 = Array.Empty<DataRelation>();
        if (ds != null && _tables.Count > 0)
        {
            array2 = new DataRelation[ds.Relations.Count];
            for (int j = 0; j < ds.Relations.Count; j++)
            {
                array2[j] = ds.Relations[j];
            }
        }
        else if (writeHierarchy && _tables.Count > 0)
        {
            CreateRelations((DataTable)_tables[0]);
            array2 = new DataRelation[_relations.Count];
            _relations.CopyTo(array2, 0);
        }
        XmlElement xmlElement6 = null;
        XmlElement xmlElement7 = null;
        foreach (DataRelation dataRelation in array2)
        {
            if ((!dataRelation.Nested || flag2) && dataRelation.ChildKeyConstraint == null)
            {
                if (xmlElement6 == null)
                {
                    xmlElement6 = xd.CreateElement("xs", "annotation", "http://www.w3.org/2001/XMLSchema");
                    xmlElement.AppendChild(xmlElement6);
                    xmlElement7 = xd.CreateElement("xs", "appinfo", "http://www.w3.org/2001/XMLSchema");
                    xmlElement6.AppendChild(xmlElement7);
                }
                xmlElement7.AppendChild(HandleRelation(dataRelation, xd));
            }
        }
        XmlComment xmlComment = null;
        bool flag4 = _namespaces.Count > 1 && !flag;
        if (_schFormat != SchemaFormat.Remoting && _schFormat != SchemaFormat.RemotingSkipSchema)
        {
            foreach (string key in _namespaces.Keys)
            {
                if (!(key == ((_ds != null) ? _ds.Namespace : dt.Namespace)) && !string.IsNullOrEmpty(key))
                {
                    XmlElement xmlElement8 = xd.CreateElement("xs", "import", "http://www.w3.org/2001/XMLSchema");
                    xmlElement8.SetAttribute("namespace", key);
                    if (_schFormat != SchemaFormat.WebService && !flag4)
                    {
                        xmlElement8.SetAttribute("schemaLocation", _fileName + "_" + _prefixes[key]?.ToString() + ".xsd");
                    }
                    xmlElement.PrependChild(xmlElement8);
                }
            }
            if (_schFormat != SchemaFormat.WebService && flag4)
            {
                xmlElement.SetAttribute("schemafragmentcount", "urn:schemas-microsoft-com:xml-msdata", _namespaces.Count.ToString(CultureInfo.InvariantCulture));
            }
            xd.AppendChild(xmlElement);
            if (_schFormat != SchemaFormat.WebService && flag4)
            {
                xd.WriteTo(xmlWriter);
            }
            else
            {
                xd.Save(xmlWriter);
            }
            xd.RemoveChild(xmlElement);
            foreach (string key2 in _namespaces.Keys)
            {
                if (key2 == ((_ds != null) ? _ds.Namespace : dt.Namespace) || string.IsNullOrEmpty(key2))
                {
                    continue;
                }
                XmlWriter xmlWriter2 = null;
                xmlWriter2 = (flag ? new XmlTextWriter(_filePath + _fileName + "_" + _prefixes[key2]?.ToString() + ".xsd", null) : xmlWriter);
                try
                {
                    if (flag)
                    {
                        if (xmlWriter2 is XmlTextWriter)
                        {
                            ((XmlTextWriter)xmlWriter2).Formatting = Formatting.Indented;
                        }
                        xmlWriter2.WriteStartDocument(standalone: true);
                    }
                    XmlElement xmlElement9 = (XmlElement)_namespaces[key2];
                    _dc.AppendChild(xmlElement9);
                    foreach (string key3 in _namespaces.Keys)
                    {
                        if (key2 == key3)
                        {
                            continue;
                        }
                        string text4 = (string)_prefixes[key3];
                        if (text4 == null)
                        {
                            continue;
                        }
                        xmlElement9.SetAttribute("xmlns:" + text4, key3);
                        XmlElement xmlElement10 = _dc.CreateElement("xs", "import", "http://www.w3.org/2001/XMLSchema");
                        xmlElement10.SetAttribute("namespace", key3);
                        if (_schFormat != SchemaFormat.WebService && !flag4)
                        {
                            if (key3 == ((_ds != null) ? _ds.Namespace : dt.Namespace))
                            {
                                xmlElement10.SetAttribute("schemaLocation", _fileName + _fileExt);
                            }
                            else
                            {
                                xmlElement10.SetAttribute("schemaLocation", _fileName + "_" + text4 + ".xsd");
                            }
                        }
                        xmlElement9.PrependChild(xmlElement10);
                    }
                    if (_schFormat != SchemaFormat.WebService && flag4)
                    {
                        _dc.WriteTo(xmlWriter2);
                    }
                    else
                    {
                        _dc.Save(xmlWriter2);
                    }
                    _dc.RemoveChild(xmlElement9);
                    if (flag)
                    {
                        xmlWriter2.WriteEndDocument();
                    }
                }
                finally
                {
                    if (flag)
                    {
                        xmlWriter2.Close();
                    }
                }
            }
        }
        else
        {
            xd.AppendChild(xmlElement);
            xd.Save(xmlWriter);
        }
        if (xmlComment != null)
        {
            xmlElement.PrependChild(xmlComment);
        }
        if (!flag)
        {
            xmlWriter.Flush();
        }
    }
 
    [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
    internal XmlElement SchemaTree(XmlDocument xd, DataTable dt)
    {
        _dsElement = xd.CreateElement("xs", "element", "http://www.w3.org/2001/XMLSchema");
        _constraintNames = new ArrayList();
        _ds = dt.DataSet;
        _dc = xd;
        _namespaces = new Hashtable();
        _prefixes = new Hashtable();
        if (_schFormat != SchemaFormat.Remoting)
        {
            _autogenerated = new Hashtable();
        }
        XmlElement xmlElement = (_sRoot = xd.CreateElement("xs", "schema", "http://www.w3.org/2001/XMLSchema"));
        WriteSchemaRoot(xd, xmlElement, dt.Namespace);
        FillDataSetElement(xd, null, dt);
        _constraintSeparator = xd.CreateElement("xs", "SHOULDNOTBEHERE", "http://www.w3.org/2001/XMLSchema");
        _dsElement.AppendChild(_constraintSeparator);
        if (_schFormat != SchemaFormat.Remoting)
        {
            if (_ds != null)
            {
                _namespaces[_ds.Namespace] = xmlElement;
                if (_ds.Namespace.Length == 0)
                {
                    _prefixes[_ds.Namespace] = null;
                }
                else
                {
                    xmlElement.SetAttribute("xmlns:mstns", _ds.Namespace);
                    _prefixes[_ds.Namespace] = "mstns";
                }
            }
            else
            {
                _namespaces[dt.Namespace] = xmlElement;
                if (dt.Namespace.Length == 0)
                {
                    _prefixes[dt.Namespace] = null;
                }
                else
                {
                    xmlElement.SetAttribute("xmlns:mstns", dt.Namespace);
                    _prefixes[dt.Namespace] = "mstns";
                }
            }
        }
        GenerateConstraintNames(dt, fromTable: true);
        XmlElement newChild = HandleTable(dt, xd, xmlElement, genNested: false);
        xmlElement.AppendChild(newChild);
        _dsElement.RemoveChild(_constraintSeparator);
        xmlElement.AppendChild(_dsElement);
        return xmlElement;
    }
 
    internal XmlElement FillDataSetElement(XmlDocument xd, DataSet ds, DataTable dt)
    {
        DataSet dataSet = ((ds != null) ? ds : dt.DataSet);
        if (dataSet != null)
        {
            _dsElement.SetAttribute("name", XmlConvert.EncodeLocalName(dataSet.DataSetName));
            _dsElement.SetAttribute("IsDataSet", "urn:schemas-microsoft-com:xml-msdata", "true");
            if (ds == null)
            {
                _dsElement.SetAttribute("MainDataTable", "urn:schemas-microsoft-com:xml-msdata", XmlConvert.EncodeLocalName((dt.Namespace.Length == 0) ? dt.TableName : (dt.Namespace + ":" + dt.TableName)));
            }
            if (dataSet.CaseSensitive)
            {
                _dsElement.SetAttribute("CaseSensitive", "urn:schemas-microsoft-com:xml-msdata", "true");
            }
            if (dataSet.ShouldSerializeLocale() || !dataSet.Locale.Equals(CultureInfo.CurrentCulture))
            {
                _dsElement.SetAttribute("Locale", "urn:schemas-microsoft-com:xml-msdata", dataSet.Locale.ToString());
            }
            else
            {
                _dsElement.SetAttribute("UseCurrentLocale", "urn:schemas-microsoft-com:xml-msdata", "true");
            }
        }
        else if (dt != null)
        {
            _dsElement.SetAttribute("name", XmlConvert.EncodeLocalName("NewDataSet"));
            _dsElement.SetAttribute("IsDataSet", "urn:schemas-microsoft-com:xml-msdata", "true");
            _dsElement.SetAttribute("MainDataTable", "urn:schemas-microsoft-com:xml-msdata", XmlConvert.EncodeLocalName((dt.Namespace.Length == 0) ? dt.TableName : (dt.Namespace + ":" + dt.TableName)));
            if (dt.CaseSensitive)
            {
                _dsElement.SetAttribute("CaseSensitive", "urn:schemas-microsoft-com:xml-msdata", "true");
            }
            if (dt.ShouldSerializeLocale() || !dt.Locale.Equals(CultureInfo.CurrentCulture))
            {
                _dsElement.SetAttribute("Locale", "urn:schemas-microsoft-com:xml-msdata", dt.Locale.ToString());
            }
            else
            {
                _dsElement.SetAttribute("UseCurrentLocale", "urn:schemas-microsoft-com:xml-msdata", "true");
            }
        }
        XmlElement xmlElement = xd.CreateElement("xs", "complexType", "http://www.w3.org/2001/XMLSchema");
        _dsElement.AppendChild(xmlElement);
        XmlElement xmlElement2 = xd.CreateElement("xs", "choice", "http://www.w3.org/2001/XMLSchema");
        xmlElement2.SetAttribute("minOccurs", "0");
        xmlElement2.SetAttribute("maxOccurs", "unbounded");
        xmlElement.AppendChild(xmlElement2);
        return xmlElement2;
    }
 
    internal void SetPath(XmlWriter xw)
    {
        FileStream fileStream = null;
        fileStream = ((xw is DataTextWriter dataTextWriter) ? (dataTextWriter.BaseStream as FileStream) : null);
        if (fileStream == null)
        {
            if (!(xw is XmlTextWriter xmlTextWriter))
            {
                return;
            }
            fileStream = xmlTextWriter.BaseStream as FileStream;
            if (fileStream == null)
            {
                return;
            }
        }
        _filePath = Path.GetDirectoryName(fileStream.Name);
        _fileName = Path.GetFileNameWithoutExtension(fileStream.Name);
        _fileExt = Path.GetExtension(fileStream.Name);
        if (!string.IsNullOrEmpty(_filePath))
        {
            _filePath += "\\";
        }
    }
 
    [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
    internal void Save(DataSet ds, XmlWriter xw)
    {
        Save(ds, null, xw);
    }
 
    [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
    internal void Save(DataTable dt, XmlWriter xw)
    {
        XmlDocument xmlDocument = new XmlDocument();
        if (_schFormat == SchemaFormat.Public)
        {
            SetPath(xw);
        }
        XmlElement newChild = SchemaTree(xmlDocument, dt);
        xmlDocument.AppendChild(newChild);
        xmlDocument.Save(xw);
    }
 
    [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
    internal void Save(DataSet ds, DataTable dt, XmlWriter xw)
    {
        Save(ds, dt, xw, writeHierarchy: false);
    }
 
    [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
    internal void Save(DataSet ds, DataTable dt, XmlWriter xw, bool writeHierarchy)
    {
        Save(ds, dt, xw, writeHierarchy, null);
    }
 
    [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
    internal void Save(DataSet ds, DataTable dt, XmlWriter xw, bool writeHierarchy, Converter<Type, string> multipleTargetConverter)
    {
        _targetConverter = multipleTargetConverter;
        XmlDocument xd = new XmlDocument();
        if (_schFormat == SchemaFormat.Public)
        {
            SetPath(xw);
        }
        if (_schFormat == SchemaFormat.WebServiceSkipSchema && xw.WriteState == WriteState.Element)
        {
            xw.WriteAttributeString("msdata", "SchemaSerializationMode", "urn:schemas-microsoft-com:xml-msdata", "ExcludeSchema");
        }
        SchemaTree(xd, xw, ds, dt, writeHierarchy);
    }
 
    internal XmlElement HandleRelation(DataRelation rel, XmlDocument dc)
    {
        XmlElement xmlElement = dc.CreateElement("msdata", "Relationship", "urn:schemas-microsoft-com:xml-msdata");
        xmlElement.SetAttribute("name", XmlConvert.EncodeLocalName(rel.RelationName));
        xmlElement.SetAttribute("parent", "urn:schemas-microsoft-com:xml-msdata", rel.ParentKey.Table.EncodedTableName);
        xmlElement.SetAttribute("child", "urn:schemas-microsoft-com:xml-msdata", rel.ChildKey.Table.EncodedTableName);
        if (_ds == null || _ds.Tables.InternalIndexOf(rel.ParentKey.Table.TableName) == -3)
        {
            xmlElement.SetAttribute("ParentTableNamespace", "urn:schemas-microsoft-com:xml-msdata", rel.ParentKey.Table.Namespace);
        }
        if (_ds == null || _ds.Tables.InternalIndexOf(rel.ChildKey.Table.TableName) == -3)
        {
            xmlElement.SetAttribute("ChildTableNamespace", "urn:schemas-microsoft-com:xml-msdata", rel.ChildKey.Table.Namespace);
        }
        DataColumn[] columnsReference = rel.ParentKey.ColumnsReference;
        string value = columnsReference[0].EncodedColumnName;
        StringBuilder stringBuilder = null;
        if (1 < columnsReference.Length)
        {
            stringBuilder = new StringBuilder();
            stringBuilder.Append(value);
            for (int i = 1; i < columnsReference.Length; i++)
            {
                stringBuilder.Append(' ').Append(columnsReference[i].EncodedColumnName);
            }
            value = stringBuilder.ToString();
        }
        xmlElement.SetAttribute("parentkey", "urn:schemas-microsoft-com:xml-msdata", value);
        columnsReference = rel.ChildKey.ColumnsReference;
        value = columnsReference[0].EncodedColumnName;
        if (1 < columnsReference.Length)
        {
            if (stringBuilder != null)
            {
                stringBuilder.Length = 0;
            }
            else
            {
                stringBuilder = new StringBuilder();
            }
            stringBuilder.Append(value);
            for (int j = 1; j < columnsReference.Length; j++)
            {
                stringBuilder.Append(' ').Append(columnsReference[j].EncodedColumnName);
            }
            value = stringBuilder.ToString();
        }
        xmlElement.SetAttribute("childkey", "urn:schemas-microsoft-com:xml-msdata", value);
        AddExtendedProperties(rel._extendedProperties, xmlElement);
        return xmlElement;
    }
 
    private static XmlElement FindSimpleType(XmlElement schema, string name)
    {
        for (XmlNode xmlNode = schema.FirstChild; xmlNode != null; xmlNode = xmlNode.NextSibling)
        {
            if (xmlNode is XmlElement)
            {
                XmlElement xmlElement = (XmlElement)xmlNode;
                if (xmlElement.GetAttribute("name") == name)
                {
                    return xmlElement;
                }
            }
        }
        return null;
    }
 
    internal XmlElement GetSchema(string NamespaceURI)
    {
        XmlElement xmlElement = (XmlElement)_namespaces[NamespaceURI];
        if (xmlElement == null)
        {
            xmlElement = _dc.CreateElement("xs", "schema", "http://www.w3.org/2001/XMLSchema");
            WriteSchemaRoot(_dc, xmlElement, NamespaceURI);
            if (!string.IsNullOrEmpty(NamespaceURI))
            {
                string text = "app" + Convert.ToString(++_prefixCount, CultureInfo.InvariantCulture);
                _sRoot.SetAttribute("xmlns:" + text, NamespaceURI);
                xmlElement.SetAttribute("xmlns:" + text, NamespaceURI);
                _prefixes[NamespaceURI] = text;
            }
            _namespaces[NamespaceURI] = xmlElement;
        }
        return xmlElement;
    }
 
    internal void HandleColumnType(DataColumn col, XmlDocument dc, XmlElement root, XmlElement schema)
    {
        string name = "type";
        if (col.ColumnMapping == MappingType.SimpleContent)
        {
            name = "base";
        }
        if (col.SimpleType != null)
        {
            for (SimpleType simpleType = col.SimpleType; simpleType != null; simpleType = simpleType.BaseSimpleType)
            {
                string name2 = simpleType.Name;
                if (name2 != null && name2.Length != 0)
                {
                    string text = ((_schFormat != SchemaFormat.Remoting) ? simpleType.Namespace : ((col.Table.DataSet != null) ? col.Table.DataSet.Namespace : col.Table.Namespace));
                    XmlElement schema2 = GetSchema(text);
                    if (simpleType.BaseSimpleType != null && simpleType.BaseSimpleType.Namespace != null && simpleType.BaseSimpleType.Namespace.Length > 0)
                    {
                        GetSchema(simpleType.BaseSimpleType.Namespace);
                    }
                    XmlNode newChild = simpleType.ToNode(dc, _prefixes, _schFormat == SchemaFormat.Remoting);
                    if (simpleType == col.SimpleType)
                    {
                        string text2 = (string)_prefixes[text];
                        if (text2 != null && text2.Length > 0)
                        {
                            if (_schFormat != SchemaFormat.Remoting)
                            {
                                root.SetAttribute(name, text2 + ":" + name2);
                            }
                            else
                            {
                                root.SetAttribute(name, name2);
                            }
                        }
                        else
                        {
                            root.SetAttribute(name, name2);
                        }
                    }
                    XmlElement xmlElement = FindSimpleType(schema2, name2);
                    if (xmlElement == null)
                    {
                        schema2.AppendChild(newChild);
                    }
                }
                else
                {
                    if (simpleType.BaseSimpleType != null && simpleType.BaseSimpleType.Namespace != null && simpleType.BaseSimpleType.Namespace.Length > 0)
                    {
                        GetSchema(simpleType.BaseSimpleType.Namespace);
                    }
                    XmlNode newChild = simpleType.ToNode(dc, _prefixes, _schFormat == SchemaFormat.Remoting);
                    root.AppendChild(newChild);
                }
            }
            return;
        }
        if (col.XmlDataType != null && col.XmlDataType.Length != 0 && XSDSchema.IsXsdType(col.XmlDataType))
        {
            root.SetAttribute(name, XSDSchema.QualifiedName(col.XmlDataType));
            return;
        }
        string text3 = XmlDataTypeName(col.DataType);
        if (text3 == null || text3.Length == 0)
        {
            if (col.DataType == typeof(Guid) || col.DataType == typeof(Type))
            {
                text3 = "string";
            }
            else
            {
                if (col.ColumnMapping == MappingType.Attribute)
                {
                    ValidateColumnMapping(col.DataType);
                }
                text3 = "anyType";
            }
        }
        root.SetAttribute(name, XSDSchema.QualifiedName(text3));
    }
 
    internal void AddColumnProperties(DataColumn col, XmlElement root)
    {
        if (col.DataType != typeof(string))
        {
            string text = XmlDataTypeName(col.DataType);
            if ((col.IsSqlType && (text.Length == 0 || col.ImplementsINullable)) || typeof(SqlXml) == col.DataType || col.DataType == typeof(DateTimeOffset) || col.DataType == typeof(BigInteger))
            {
                root.SetAttribute("DataType", "urn:schemas-microsoft-com:xml-msdata", col.DataType.FullName);
            }
            else if (text.Length == 0 || col.ImplementsINullable || (text == "anyType" && col.XmlDataType != "anyType"))
            {
                SetMSDataAttribute(root, col.DataType);
            }
        }
        if (col.ReadOnly)
        {
            root.SetAttribute("ReadOnly", "urn:schemas-microsoft-com:xml-msdata", "true");
        }
        if (col.Expression.Length != 0)
        {
            root.SetAttribute("Expression", "urn:schemas-microsoft-com:xml-msdata", col.Expression);
        }
        if (col.AutoIncrement)
        {
            root.SetAttribute("AutoIncrement", "urn:schemas-microsoft-com:xml-msdata", "true");
        }
        if (col.AutoIncrementSeed != 0L)
        {
            root.SetAttribute("AutoIncrementSeed", "urn:schemas-microsoft-com:xml-msdata", col.AutoIncrementSeed.ToString(CultureInfo.InvariantCulture));
        }
        if (col.AutoIncrementStep != 1)
        {
            root.SetAttribute("AutoIncrementStep", "urn:schemas-microsoft-com:xml-msdata", col.AutoIncrementStep.ToString(CultureInfo.InvariantCulture));
        }
        if (col.Caption != col.ColumnName)
        {
            root.SetAttribute("Caption", "urn:schemas-microsoft-com:xml-msdata", col.Caption);
        }
        if (col.Prefix.Length != 0)
        {
            root.SetAttribute("Prefix", "urn:schemas-microsoft-com:xml-msdata", col.Prefix);
        }
        if (col.DataType == typeof(DateTime) && col.DateTimeMode != DataSetDateTime.UnspecifiedLocal)
        {
            root.SetAttribute("DateTimeMode", "urn:schemas-microsoft-com:xml-msdata", col.DateTimeMode.ToString());
        }
    }
 
    private string FindTargetNamespace(DataTable table)
    {
        string text = (table.TypeName.IsEmpty ? table.Namespace : table.TypeName.Namespace);
        if (string.IsNullOrEmpty(text))
        {
            DataRelation[] nestedParentRelations = table.NestedParentRelations;
            if (nestedParentRelations.Length != 0)
            {
                for (int i = 0; i < nestedParentRelations.Length; i++)
                {
                    DataTable parentTable = nestedParentRelations[i].ParentTable;
                    if (table != parentTable)
                    {
                        text = FindTargetNamespace(parentTable);
                        if (!string.IsNullOrEmpty(text))
                        {
                            break;
                        }
                    }
                }
            }
            else
            {
                text = _ds.Namespace;
            }
        }
        return text;
    }
 
    [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
    internal XmlElement HandleColumn(DataColumn col, XmlDocument dc, XmlElement schema, bool fWriteOrdinal)
    {
        string localName = ((col.ColumnMapping != MappingType.Element) ? "attribute" : "element");
        XmlElement xmlElement = dc.CreateElement("xs", localName, "http://www.w3.org/2001/XMLSchema");
        xmlElement.SetAttribute("name", col.EncodedColumnName);
        if (col.Namespace.Length == 0)
        {
            DataTable table = col.Table;
            string text = FindTargetNamespace(table);
            if (col.Namespace != text)
            {
                xmlElement.SetAttribute("form", "unqualified");
            }
        }
        if (col.GetType() != typeof(DataColumn))
        {
            AddXdoProperties(col, xmlElement, dc);
        }
        else
        {
            AddColumnProperties(col, xmlElement);
        }
        AddExtendedProperties(col._extendedProperties, xmlElement);
        HandleColumnType(col, dc, xmlElement, schema);
        if (col.ColumnMapping == MappingType.Hidden)
        {
            if (!col.AllowDBNull)
            {
                xmlElement.SetAttribute("AllowDBNull", "urn:schemas-microsoft-com:xml-msdata", "false");
            }
            if (!col.DefaultValueIsNull)
            {
                if (col.DataType == typeof(bool))
                {
                    xmlElement.SetAttribute("DefaultValue", "urn:schemas-microsoft-com:xml-msdata", ((bool)col.DefaultValue) ? "true" : "false");
                }
                else
                {
                    ValidateColumnMapping(col.DataType);
                    xmlElement.SetAttribute("DefaultValue", "urn:schemas-microsoft-com:xml-msdata", col.ConvertObjectToXml(col.DefaultValue));
                }
            }
        }
        if (!col.DefaultValueIsNull && col.ColumnMapping != MappingType.Hidden)
        {
            ValidateColumnMapping(col.DataType);
            if (col.ColumnMapping == MappingType.Attribute && !col.AllowDBNull)
            {
                if (col.DataType == typeof(bool))
                {
                    xmlElement.SetAttribute("DefaultValue", "urn:schemas-microsoft-com:xml-msdata", ((bool)col.DefaultValue) ? "true" : "false");
                }
                else
                {
                    xmlElement.SetAttribute("DefaultValue", "urn:schemas-microsoft-com:xml-msdata", col.ConvertObjectToXml(col.DefaultValue));
                }
            }
            else if (col.DataType == typeof(bool))
            {
                xmlElement.SetAttribute("default", ((bool)col.DefaultValue) ? "true" : "false");
            }
            else if (!col.IsCustomType)
            {
                xmlElement.SetAttribute("default", col.ConvertObjectToXml(col.DefaultValue));
            }
        }
        if (_schFormat == SchemaFormat.Remoting)
        {
            xmlElement.SetAttribute("targetNamespace", "urn:schemas-microsoft-com:xml-msdata", col.Namespace);
        }
        else if (col.Namespace != (col.Table.TypeName.IsEmpty ? col.Table.Namespace : col.Table.TypeName.Namespace) && col.Namespace.Length != 0)
        {
            XmlElement schema2 = GetSchema(col.Namespace);
            if (FindTypeNode(schema2, col.EncodedColumnName) == null)
            {
                schema2.AppendChild(xmlElement);
            }
            xmlElement = _dc.CreateElement("xs", localName, "http://www.w3.org/2001/XMLSchema");
            xmlElement.SetAttribute("ref", _prefixes[col.Namespace]?.ToString() + ":" + col.EncodedColumnName);
            if (col.Table.Namespace != _ds.Namespace)
            {
                GetSchema(col.Table.Namespace);
            }
        }
        int num = ((!col.AllowDBNull) ? 1 : 0);
        if (col.ColumnMapping == MappingType.Attribute && num != 0)
        {
            xmlElement.SetAttribute("use", "required");
        }
        if (col.ColumnMapping == MappingType.Hidden)
        {
            xmlElement.SetAttribute("use", "prohibited");
        }
        else if (col.ColumnMapping != MappingType.Attribute && num != 1)
        {
            xmlElement.SetAttribute("minOccurs", num.ToString(CultureInfo.InvariantCulture));
        }
        if (col.ColumnMapping == MappingType.Element && fWriteOrdinal)
        {
            xmlElement.SetAttribute("Ordinal", "urn:schemas-microsoft-com:xml-msdata", col.Ordinal.ToString(CultureInfo.InvariantCulture));
        }
        return xmlElement;
    }
 
    internal static string TranslateAcceptRejectRule(AcceptRejectRule rule)
    {
        return rule switch
        {
            AcceptRejectRule.Cascade => "Cascade", 
            AcceptRejectRule.None => "None", 
            _ => null, 
        };
    }
 
    internal static string TranslateRule(Rule rule)
    {
        return rule switch
        {
            Rule.Cascade => "Cascade", 
            Rule.None => "None", 
            Rule.SetNull => "SetNull", 
            Rule.SetDefault => "SetDefault", 
            _ => null, 
        };
    }
 
    internal void AppendChildWithoutRef(XmlElement node, string Namespace, XmlElement el, string refString)
    {
        XmlElement schema = GetSchema(Namespace);
        if (FindTypeNode(schema, el.GetAttribute("name")) == null)
        {
            schema.AppendChild(el);
        }
    }
 
    internal XmlElement FindTypeNode(XmlElement node, string strType)
    {
        if (node == null)
        {
            return null;
        }
        for (XmlNode xmlNode = node.FirstChild; xmlNode != null; xmlNode = xmlNode.NextSibling)
        {
            if (xmlNode is XmlElement)
            {
                XmlElement xmlElement = (XmlElement)xmlNode;
                if ((XMLSchema.FEqualIdentity(xmlElement, "element", "http://www.w3.org/2001/XMLSchema") || XMLSchema.FEqualIdentity(xmlElement, "attribute", "http://www.w3.org/2001/XMLSchema") || XMLSchema.FEqualIdentity(xmlElement, "complexType", "http://www.w3.org/2001/XMLSchema") || XMLSchema.FEqualIdentity(xmlElement, "simpleType", "http://www.w3.org/2001/XMLSchema")) && xmlElement.GetAttribute("name") == strType)
                {
                    return xmlElement;
                }
            }
        }
        return null;
    }
 
    [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
    internal XmlElement HandleTable(DataTable table, XmlDocument dc, XmlElement schema)
    {
        return HandleTable(table, dc, schema, genNested: true);
    }
 
    private bool HasMixedColumns(DataTable table)
    {
        bool flag = false;
        bool flag2 = false;
        foreach (DataColumn column in table.Columns)
        {
            if (!flag2 && column.ColumnMapping == MappingType.Element)
            {
                flag2 = true;
            }
            if (!flag && (column.ColumnMapping == MappingType.Attribute || column.ColumnMapping == MappingType.Hidden))
            {
                flag = !AutoGenerated(column);
            }
            if (flag && flag2)
            {
                return true;
            }
        }
        return false;
    }
 
    internal static bool AutoGenerated(DataColumn col)
    {
        if (col.ColumnMapping != MappingType.Hidden)
        {
            return false;
        }
        if (col.DataType != typeof(int))
        {
            return false;
        }
        string text = col.Table.TableName + "_Id";
        if (col.ColumnName == text || col.ColumnName == text + "_0")
        {
            return true;
        }
        text = string.Empty;
        foreach (DataRelation parentRelation in col.Table.ParentRelations)
        {
            if (parentRelation.Nested && parentRelation.ChildColumnsReference.Length == 1 && parentRelation.ChildColumnsReference[0] == col && parentRelation.ParentColumnsReference.Length == 1)
            {
                text = parentRelation.ParentColumnsReference[0].Table.TableName + "_Id";
            }
        }
        if (col.ColumnName == text || col.ColumnName == text + "_0")
        {
            return true;
        }
        return false;
    }
 
    internal static bool AutoGenerated(DataRelation rel)
    {
        string value = rel.ParentTable.TableName + "_" + rel.ChildTable.TableName;
        if (!rel.RelationName.StartsWith(value, StringComparison.Ordinal))
        {
            return false;
        }
        if (rel.ExtendedProperties.Count > 0)
        {
            return false;
        }
        return true;
    }
 
    internal static bool AutoGenerated(UniqueConstraint unique)
    {
        if (!unique.ConstraintName.StartsWith("Constraint", StringComparison.Ordinal))
        {
            return false;
        }
        if (unique.Key.ColumnsReference.Length != 1)
        {
            return false;
        }
        if (unique.ExtendedProperties.Count > 0)
        {
            return false;
        }
        return AutoGenerated(unique.Key.ColumnsReference[0]);
    }
 
    private bool AutoGenerated(ForeignKeyConstraint fk)
    {
        return AutoGenerated(fk, checkRelation: true);
    }
 
    internal static bool AutoGenerated(ForeignKeyConstraint fk, bool checkRelation)
    {
        DataRelation dataRelation = fk.FindParentRelation();
        if (checkRelation)
        {
            if (dataRelation == null)
            {
                return false;
            }
            if (!AutoGenerated(dataRelation))
            {
                return false;
            }
            if (dataRelation.RelationName != fk.ConstraintName)
            {
                return false;
            }
        }
        if (fk.ExtendedProperties.Count > 0)
        {
            return false;
        }
        if (fk.AcceptRejectRule != 0)
        {
            return false;
        }
        if (fk.DeleteRule != Rule.Cascade)
        {
            return false;
        }
        if (fk.DeleteRule != Rule.Cascade)
        {
            return false;
        }
        if (fk.RelatedColumnsReference.Length != 1)
        {
            return false;
        }
        return AutoGenerated(fk.RelatedColumnsReference[0]);
    }
 
    private bool IsAutoGenerated(object o)
    {
        if (_schFormat != SchemaFormat.Remoting)
        {
            return _autogenerated[o] != null;
        }
        return false;
    }
 
    [RequiresUnreferencedCode("Members from serialized types may be trimmed if not referenced directly.")]
    internal XmlElement HandleTable(DataTable table, XmlDocument dc, XmlElement schema, bool genNested)
    {
        XmlElement xmlElement = dc.CreateElement("xs", "element", "http://www.w3.org/2001/XMLSchema");
        bool flag = false;
        bool flag2 = false;
        if ((table.DataSet == null || (_ds != null && table.Namespace != _ds.Namespace)) && _schFormat == SchemaFormat.Remoting)
        {
            xmlElement.SetAttribute("targetNamespace", "urn:schemas-microsoft-com:xml-msdata", table.Namespace);
        }
        xmlElement.SetAttribute("name", table.EncodedTableName);
        if (table.Namespace.Length == 0)
        {
            DataTable dataTable = table;
            string text = dataTable.Namespace;
            while (string.IsNullOrEmpty(text))
            {
                DataRelation[] nestedParentRelations = dataTable.NestedParentRelations;
                if (nestedParentRelations.Length == 0)
                {
                    text = ((_ds != null) ? _ds.Namespace : "");
                    break;
                }
                int num = -1;
                for (int i = 0; i < nestedParentRelations.Length; i++)
                {
                    if (nestedParentRelations[i].ParentTable != dataTable)
                    {
                        num = i;
                        break;
                    }
                }
                if (num == -1)
                {
                    break;
                }
                dataTable = nestedParentRelations[num].ParentTable;
                text = dataTable.Namespace;
            }
            if (table.Namespace != text)
            {
                xmlElement.SetAttribute("form", "unqualified");
                flag2 = true;
            }
        }
        if (table.ShouldSerializeCaseSensitive())
        {
            xmlElement.SetAttribute("CaseSensitive", "urn:schemas-microsoft-com:xml-msdata", table.CaseSensitive.ToString());
        }
        if (table.ShouldSerializeLocale())
        {
            xmlElement.SetAttribute("Locale", "urn:schemas-microsoft-com:xml-msdata", table.Locale.ToString());
        }
        AddXdoProperties(table, xmlElement, dc);
        DataColumnCollection columns = table.Columns;
        int count = columns.Count;
        int num2 = 0;
        if (count == 1 || count == 2)
        {
            for (int j = 0; j < count; j++)
            {
                DataColumn dataColumn = columns[j];
                if (dataColumn.ColumnMapping == MappingType.Hidden)
                {
                    DataRelationCollection childRelations = table.ChildRelations;
                    for (int k = 0; k < childRelations.Count; k++)
                    {
                        if (childRelations[k].Nested && childRelations[k].ParentKey.ColumnsReference.Length == 1 && childRelations[k].ParentKey.ColumnsReference[0] == dataColumn)
                        {
                            num2++;
                        }
                    }
                }
                if (dataColumn.ColumnMapping == MappingType.Element)
                {
                    num2++;
                }
            }
        }
        if (table._repeatableElement && num2 == 1)
        {
            DataColumn dataColumn2 = table.Columns[0];
            string text2 = XmlDataTypeName(dataColumn2.DataType);
            if (text2 == null || text2.Length == 0)
            {
                text2 = "anyType";
            }
            xmlElement.SetAttribute("type", XSDSchema.QualifiedName(text2));
            return xmlElement;
        }
        XmlElement xmlElement2 = dc.CreateElement("xs", "complexType", "http://www.w3.org/2001/XMLSchema");
        if (!table.TypeName.IsEmpty && _schFormat != SchemaFormat.Remoting)
        {
            XmlElement xmlElement3 = GetSchema(table.TypeName.Namespace);
            if (string.IsNullOrEmpty(table.TypeName.Namespace))
            {
                xmlElement3 = ((_ds != null) ? (flag2 ? GetSchema(_ds.Namespace) : GetSchema(table.Namespace)) : GetSchema(table.Namespace));
            }
            if (FindTypeNode(xmlElement3, table.TypeName.Name) == null)
            {
                xmlElement3.AppendChild(xmlElement2);
            }
            xmlElement2.SetAttribute("name", table.TypeName.Name);
        }
        else
        {
            xmlElement.AppendChild(xmlElement2);
        }
        if (!table.TypeName.IsEmpty && _schFormat != SchemaFormat.Remoting)
        {
            xmlElement.SetAttribute("type", NewDiffgramGen.QualifiedName((string)_prefixes[table.TypeName.Namespace], table.TypeName.Name));
        }
        XmlElement xmlElement4 = null;
        DataColumn xmlText = table.XmlText;
        if (xmlText != null)
        {
            XmlElement xmlElement5 = dc.CreateElement("xs", "simpleContent", "http://www.w3.org/2001/XMLSchema");
            if (xmlText.GetType() != typeof(DataColumn))
            {
                AddXdoProperties(xmlText, xmlElement5, dc);
            }
            else
            {
                AddColumnProperties(xmlText, xmlElement5);
            }
            AddExtendedProperties(xmlText._extendedProperties, xmlElement5);
            if (xmlText.AllowDBNull)
            {
                xmlElement.SetAttribute("nillable", string.Empty, "true");
            }
            if (!xmlText.DefaultValueIsNull)
            {
                ValidateColumnMapping(xmlText.DataType);
                xmlElement5.SetAttribute("DefaultValue", "urn:schemas-microsoft-com:xml-msdata", xmlText.ConvertObjectToXml(xmlText.DefaultValue));
            }
            xmlElement5.SetAttribute("ColumnName", "urn:schemas-microsoft-com:xml-msdata", xmlText.ColumnName);
            xmlElement5.SetAttribute("Ordinal", "urn:schemas-microsoft-com:xml-msdata", xmlText.Ordinal.ToString(CultureInfo.InvariantCulture));
            xmlElement2.AppendChild(xmlElement5);
            XmlElement xmlElement6 = dc.CreateElement("xs", "extension", "http://www.w3.org/2001/XMLSchema");
            xmlElement5.AppendChild(xmlElement6);
            HandleColumnType(xmlText, dc, xmlElement6, schema);
            xmlElement2 = xmlElement6;
        }
        xmlElement4 = dc.CreateElement("xs", "sequence", "http://www.w3.org/2001/XMLSchema");
        xmlElement2.AppendChild(xmlElement4);
        flag = HasMixedColumns(table);
        for (int l = 0; l < count; l++)
        {
            DataColumn dataColumn3 = columns[l];
            if (dataColumn3.ColumnMapping != MappingType.SimpleContent && (dataColumn3.ColumnMapping == MappingType.Attribute || dataColumn3.ColumnMapping == MappingType.Element || dataColumn3.ColumnMapping == MappingType.Hidden) && !IsAutoGenerated(dataColumn3))
            {
                bool flag3 = dataColumn3.ColumnMapping != MappingType.Element;
                XmlElement newChild = HandleColumn(dataColumn3, dc, schema, flag);
                XmlElement xmlElement7 = (flag3 ? xmlElement2 : xmlElement4);
                xmlElement7.AppendChild(newChild);
            }
        }
        if (table.XmlText == null && genNested)
        {
            DataRelationCollection childRelations2 = table.ChildRelations;
            for (int m = 0; m < childRelations2.Count; m++)
            {
                if (!childRelations2[m].Nested)
                {
                    continue;
                }
                DataTable childTable = childRelations2[m].ChildTable;
                XmlElement xmlElement8;
                if (childTable == table)
                {
                    xmlElement8 = dc.CreateElement("xs", "element", "http://www.w3.org/2001/XMLSchema");
                    xmlElement8.SetAttribute("ref", table.EncodedTableName);
                }
                else if (childTable.NestedParentsCount > 1)
                {
                    xmlElement8 = dc.CreateElement("xs", "element", "http://www.w3.org/2001/XMLSchema");
                    xmlElement8.SetAttribute("ref", childTable.EncodedTableName);
                }
                else
                {
                    xmlElement8 = HandleTable(childTable, dc, schema);
                }
                if (childTable.Namespace == table.Namespace)
                {
                    xmlElement8.SetAttribute("minOccurs", "0");
                    xmlElement8.SetAttribute("maxOccurs", "unbounded");
                }
                if (childTable.Namespace == table.Namespace || childTable.Namespace.Length == 0 || _schFormat == SchemaFormat.Remoting)
                {
                    xmlElement4.AppendChild(xmlElement8);
                }
                else
                {
                    if (childTable.NestedParentsCount <= 1)
                    {
                        GetSchema(childTable.Namespace).AppendChild(xmlElement8);
                    }
                    xmlElement8 = dc.CreateElement("xs", "element", "http://www.w3.org/2001/XMLSchema");
                    xmlElement8.SetAttribute("ref", (string)_prefixes[childTable.Namespace] + ":" + childTable.EncodedTableName);
                    xmlElement4.AppendChild(xmlElement8);
                }
                if (childRelations2[m].ChildKeyConstraint == null)
                {
                    XmlElement xmlElement9 = _dc.CreateElement("xs", "annotation", "http://www.w3.org/2001/XMLSchema");
                    xmlElement8.PrependChild(xmlElement9);
                    XmlElement xmlElement10 = _dc.CreateElement("xs", "appinfo", "http://www.w3.org/2001/XMLSchema");
                    xmlElement9.AppendChild(xmlElement10);
                    xmlElement10.AppendChild(HandleRelation(childRelations2[m], dc));
                }
            }
        }
        if (xmlElement4 != null && !xmlElement4.HasChildNodes)
        {
            xmlElement2.RemoveChild(xmlElement4);
        }
        ConstraintCollection constraints = table.Constraints;
        string text3 = ((_ds == null) ? string.Empty : ((_ds.Namespace.Length != 0) ? "mstns:" : string.Empty));
        if (_schFormat != SchemaFormat.Remoting)
        {
            GetSchema(table.Namespace);
            text3 = ((table.Namespace.Length != 0) ? ((string)_prefixes[table.Namespace] + ":") : string.Empty);
        }
        for (int n = 0; n < constraints.Count; n++)
        {
            XmlElement xmlElement11 = null;
            if (constraints[n] is UniqueConstraint)
            {
                UniqueConstraint uniqueConstraint = (UniqueConstraint)constraints[n];
                if (IsAutoGenerated(uniqueConstraint))
                {
                    continue;
                }
                DataColumn[] columnsReference = uniqueConstraint.Key.ColumnsReference;
                xmlElement11 = dc.CreateElement("xs", "unique", "http://www.w3.org/2001/XMLSchema");
                if (_ds == null || _ds.Tables.InternalIndexOf(table.TableName) == -3)
                {
                    xmlElement11.SetAttribute("TableNamespace", "urn:schemas-microsoft-com:xml-msdata", table.Namespace);
                }
                xmlElement11.SetAttribute("name", XmlConvert.EncodeLocalName(uniqueConstraint.SchemaName));
                if (uniqueConstraint.ConstraintName != uniqueConstraint.SchemaName)
                {
                    xmlElement11.SetAttribute("ConstraintName", "urn:schemas-microsoft-com:xml-msdata", uniqueConstraint.ConstraintName);
                }
                AddExtendedProperties(uniqueConstraint._extendedProperties, xmlElement11);
                XmlElement xmlElement12 = dc.CreateElement("xs", "selector", "http://www.w3.org/2001/XMLSchema");
                xmlElement12.SetAttribute("xpath", ".//" + text3 + table.EncodedTableName);
                xmlElement11.AppendChild(xmlElement12);
                if (uniqueConstraint.IsPrimaryKey)
                {
                    xmlElement11.SetAttribute("PrimaryKey", "urn:schemas-microsoft-com:xml-msdata", "true");
                }
                if (columnsReference.Length != 0)
                {
                    StringBuilder stringBuilder = new StringBuilder();
                    for (int num3 = 0; num3 < columnsReference.Length; num3++)
                    {
                        stringBuilder.Length = 0;
                        if (_schFormat != SchemaFormat.Remoting)
                        {
                            GetSchema(columnsReference[num3].Namespace);
                            if (!string.IsNullOrEmpty(columnsReference[num3].Namespace))
                            {
                                stringBuilder.Append(_prefixes[columnsReference[num3].Namespace]).Append(':');
                            }
                            stringBuilder.Append(columnsReference[num3].EncodedColumnName);
                        }
                        else
                        {
                            stringBuilder.Append(text3).Append(columnsReference[num3].EncodedColumnName);
                        }
                        if (columnsReference[num3].ColumnMapping == MappingType.Attribute || columnsReference[num3].ColumnMapping == MappingType.Hidden)
                        {
                            stringBuilder.Insert(0, '@');
                        }
                        XmlElement xmlElement13 = dc.CreateElement("xs", "field", "http://www.w3.org/2001/XMLSchema");
                        xmlElement13.SetAttribute("xpath", stringBuilder.ToString());
                        xmlElement11.AppendChild(xmlElement13);
                    }
                }
                _dsElement.InsertBefore(xmlElement11, _constraintSeparator);
            }
            else
            {
                if (!(constraints[n] is ForeignKeyConstraint && genNested))
                {
                    continue;
                }
                ForeignKeyConstraint foreignKeyConstraint = (ForeignKeyConstraint)constraints[n];
                if ((_tables.Count > 0 && (!_tables.Contains(foreignKeyConstraint.RelatedTable) || !_tables.Contains(foreignKeyConstraint.Table))) || IsAutoGenerated(foreignKeyConstraint))
                {
                    continue;
                }
                DataRelation dataRelation = foreignKeyConstraint.FindParentRelation();
                DataColumn[] columnsReference = foreignKeyConstraint.RelatedColumnsReference;
                UniqueConstraint uniqueConstraint2 = (UniqueConstraint)foreignKeyConstraint.RelatedTable.Constraints.FindConstraint(new UniqueConstraint("TEMP", columnsReference));
                XmlElement xmlElement12;
                if (uniqueConstraint2 == null)
                {
                    xmlElement11 = dc.CreateElement("xs", "key", "http://www.w3.org/2001/XMLSchema");
                    xmlElement11.SetAttribute("name", XmlConvert.EncodeLocalName(foreignKeyConstraint.SchemaName));
                    if (_ds == null || _ds.Tables.InternalIndexOf(table.TableName) == -3)
                    {
                        xmlElement11.SetAttribute("TableNamespace", "urn:schemas-microsoft-com:xml-msdata", table.Namespace);
                    }
                    xmlElement12 = dc.CreateElement("xs", "selector", "http://www.w3.org/2001/XMLSchema");
                    xmlElement12.SetAttribute("xpath", ".//" + text3 + foreignKeyConstraint.RelatedTable.EncodedTableName);
                    xmlElement11.AppendChild(xmlElement12);
                    if (columnsReference.Length != 0)
                    {
                        StringBuilder stringBuilder2 = new StringBuilder();
                        for (int num4 = 0; num4 < columnsReference.Length; num4++)
                        {
                            stringBuilder2.Length = 0;
                            if (_schFormat != SchemaFormat.Remoting)
                            {
                                GetSchema(columnsReference[num4].Namespace);
                                if (!string.IsNullOrEmpty(columnsReference[num4].Namespace))
                                {
                                    stringBuilder2.Append(_prefixes[columnsReference[num4].Namespace]).Append(':');
                                }
                                stringBuilder2.Append(columnsReference[num4].EncodedColumnName);
                            }
                            else
                            {
                                stringBuilder2.Append(text3).Append(columnsReference[num4].EncodedColumnName);
                            }
                            if (columnsReference[num4].ColumnMapping == MappingType.Attribute || columnsReference[num4].ColumnMapping == MappingType.Hidden)
                            {
                                stringBuilder2.Insert(0, '@');
                            }
                            XmlElement xmlElement13 = dc.CreateElement("xs", "field", "http://www.w3.org/2001/XMLSchema");
                            xmlElement13.SetAttribute("xpath", stringBuilder2.ToString());
                            xmlElement11.AppendChild(xmlElement13);
                        }
                    }
                    _dsElement.InsertBefore(xmlElement11, _constraintSeparator);
                }
                xmlElement11 = dc.CreateElement("xs", "keyref", "http://www.w3.org/2001/XMLSchema");
                xmlElement11.SetAttribute("name", XmlConvert.EncodeLocalName(foreignKeyConstraint.SchemaName));
                if (_ds == null || _ds.Tables.InternalIndexOf(foreignKeyConstraint.RelatedTable.TableName) == -3)
                {
                    xmlElement11.SetAttribute("TableNamespace", "urn:schemas-microsoft-com:xml-msdata", foreignKeyConstraint.Table.Namespace);
                }
                if (uniqueConstraint2 == null)
                {
                    xmlElement11.SetAttribute("refer", XmlConvert.EncodeLocalName(foreignKeyConstraint.SchemaName));
                }
                else
                {
                    xmlElement11.SetAttribute("refer", XmlConvert.EncodeLocalName(uniqueConstraint2.SchemaName));
                }
                AddExtendedProperties(foreignKeyConstraint._extendedProperties, xmlElement11, typeof(ForeignKeyConstraint));
                if (foreignKeyConstraint.ConstraintName != foreignKeyConstraint.SchemaName)
                {
                    xmlElement11.SetAttribute("ConstraintName", "urn:schemas-microsoft-com:xml-msdata", foreignKeyConstraint.ConstraintName);
                }
                if (dataRelation == null)
                {
                    xmlElement11.SetAttribute("ConstraintOnly", "urn:schemas-microsoft-com:xml-msdata", "true");
                }
                else
                {
                    if (dataRelation.Nested)
                    {
                        xmlElement11.SetAttribute("IsNested", "urn:schemas-microsoft-com:xml-msdata", "true");
                    }
                    AddExtendedProperties(dataRelation._extendedProperties, xmlElement11, typeof(DataRelation));
                    if (foreignKeyConstraint.ConstraintName != dataRelation.RelationName)
                    {
                        xmlElement11.SetAttribute("RelationName", "urn:schemas-microsoft-com:xml-msdata", XmlConvert.EncodeLocalName(dataRelation.RelationName));
                    }
                }
                xmlElement12 = dc.CreateElement("xs", "selector", "http://www.w3.org/2001/XMLSchema");
                xmlElement12.SetAttribute("xpath", ".//" + text3 + table.EncodedTableName);
                xmlElement11.AppendChild(xmlElement12);
                if (foreignKeyConstraint.AcceptRejectRule != 0)
                {
                    xmlElement11.SetAttribute("AcceptRejectRule", "urn:schemas-microsoft-com:xml-msdata", TranslateAcceptRejectRule(foreignKeyConstraint.AcceptRejectRule));
                }
                if (foreignKeyConstraint.UpdateRule != Rule.Cascade)
                {
                    xmlElement11.SetAttribute("UpdateRule", "urn:schemas-microsoft-com:xml-msdata", TranslateRule(foreignKeyConstraint.UpdateRule));
                }
                if (foreignKeyConstraint.DeleteRule != Rule.Cascade)
                {
                    xmlElement11.SetAttribute("DeleteRule", "urn:schemas-microsoft-com:xml-msdata", TranslateRule(foreignKeyConstraint.DeleteRule));
                }
                columnsReference = foreignKeyConstraint.Columns;
                if (columnsReference.Length != 0)
                {
                    StringBuilder stringBuilder3 = new StringBuilder();
                    for (int num5 = 0; num5 < columnsReference.Length; num5++)
                    {
                        stringBuilder3.Length = 0;
                        if (_schFormat != SchemaFormat.Remoting)
                        {
                            GetSchema(columnsReference[num5].Namespace);
                            if (!string.IsNullOrEmpty(columnsReference[num5].Namespace))
                            {
                                stringBuilder3.Append(_prefixes[columnsReference[num5].Namespace]).Append(':');
                            }
                            stringBuilder3.Append(columnsReference[num5].EncodedColumnName);
                        }
                        else
                        {
                            stringBuilder3.Append(text3).Append(columnsReference[num5].EncodedColumnName);
                        }
                        if (columnsReference[num5].ColumnMapping == MappingType.Attribute || columnsReference[num5].ColumnMapping == MappingType.Hidden)
                        {
                            stringBuilder3.Insert(0, '@');
                        }
                        XmlElement xmlElement13 = dc.CreateElement("xs", "field", "http://www.w3.org/2001/XMLSchema");
                        xmlElement13.SetAttribute("xpath", stringBuilder3.ToString());
                        xmlElement11.AppendChild(xmlElement13);
                    }
                }
                _dsElement.InsertAfter(xmlElement11, _constraintSeparator);
            }
        }
        AddExtendedProperties(table._extendedProperties, xmlElement);
        return xmlElement;
    }
 
    private void SetMSDataAttribute(XmlElement root, Type type)
    {
        string value = DataStorage.GetQualifiedName(type);
        try
        {
            if (_targetConverter != null)
            {
                value = _targetConverter(type);
            }
            if (!string.IsNullOrEmpty(value))
            {
                root.SetAttribute("DataType", "urn:schemas-microsoft-com:xml-msdata", value);
            }
        }
        catch (Exception ex) when (ADP.IsCatchableExceptionType(ex))
        {
            ExceptionBuilder.ThrowMultipleTargetConverter(ex);
        }
        if (string.IsNullOrEmpty(value))
        {
            ExceptionBuilder.ThrowMultipleTargetConverter(null);
        }
    }
}