ShouldSerializeLocale() private method

private ShouldSerializeLocale ( ) : bool
return bool
        internal XmlElement FillDataSetElement(XmlDocument xd, DataSet ds, DataTable dt) {
            DataSet dataSet = (ds != null) ? ds : dt.DataSet;
            if (dataSet != null) {
                    dsElement.SetAttribute(Keywords.NAME, XmlConvert.EncodeLocalName(dataSet.DataSetName));
                    dsElement.SetAttribute(Keywords.MSD_ISDATASET, Keywords.MSDNS, Keywords.TRUE);
                    if (ds == null)
                        dsElement.SetAttribute(Keywords.MSD_MAINDATATABLE, Keywords.MSDNS, XmlConvert.EncodeLocalName(((dt.Namespace.Length == 0)?dt.TableName : (dt.Namespace + ":" + dt.TableName))));

                    // Add CaseSensitive and locale properties
                    if (dataSet.CaseSensitive) {
                        dsElement.SetAttribute(Keywords.MSD_CASESENSITIVE, Keywords.MSDNS, Keywords.TRUE);
                    }
                    if (dataSet.ShouldSerializeLocale() || !dataSet.Locale.Equals(CultureInfo.CurrentCulture)) {
                        dsElement.SetAttribute(Keywords.MSD_LOCALE, Keywords.MSDNS, dataSet.Locale.ToString());
                    }
                    else {
                        dsElement.SetAttribute(Keywords.MSD_USECURRENTLOCALE, Keywords.MSDNS, Keywords.TRUE);
                    }
            }
            else { // No DataSet
                if (dt != null) {
                    dsElement.SetAttribute(Keywords.NAME, XmlConvert.EncodeLocalName("NewDataSet"));
                    dsElement.SetAttribute(Keywords.MSD_ISDATASET, Keywords.MSDNS, Keywords.TRUE);
                    dsElement.SetAttribute(Keywords.MSD_MAINDATATABLE, Keywords.MSDNS, XmlConvert.EncodeLocalName(((dt.Namespace.Length == 0)?dt.TableName : (dt.Namespace + ":" + dt.TableName))));

                    if (dt.CaseSensitive) { // WebData 111631 :it is a bug to go and write casesensitive attrib as 'true', by default
                        dsElement.SetAttribute(Keywords.MSD_CASESENSITIVE, Keywords.MSDNS, Keywords.TRUE);
                    }
                    if (dt.ShouldSerializeLocale() || !dt.Locale.Equals(CultureInfo.CurrentCulture)) {
                        dsElement.SetAttribute(Keywords.MSD_LOCALE, Keywords.MSDNS, dt.Locale.ToString());
                    }
                    else {
                        dsElement.SetAttribute(Keywords.MSD_USECURRENTLOCALE, Keywords.MSDNS, Keywords.TRUE);
                    }
                }
            }

            XmlElement type = xd.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_COMPLEXTYPE, Keywords.XSDNS);
            dsElement.AppendChild(type);
            XmlElement compositor = xd.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_CHOICE, Keywords.XSDNS);
            compositor.SetAttribute(Keywords.MINOCCURS, Keywords.ZERO_DIGIT);
            compositor.SetAttribute(Keywords.MAXOCCURS, Keywords.ZERO_OR_MORE);
            type.AppendChild(compositor);

            return compositor;
        }
        internal XmlElement HandleTable(DataTable table, XmlDocument dc, XmlElement schema, bool genNested) {
            XmlElement root = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_ELEMENT, Keywords.XSDNS);
            bool fWriteOrdinals = false;
            bool fUnqualified = false;

            if (((table.DataSet == null) || (_ds!= null &&  table.Namespace != _ds.Namespace)) && (schFormat == SchemaFormat.Remoting))
                root.SetAttribute( Keywords.TARGETNAMESPACE, Keywords.MSDNS, table.Namespace);

            // First add any attributes.
            root.SetAttribute( Keywords.NAME, table.EncodedTableName );

            if (table.Namespace.Length == 0) {
                DataTable _table = table;
                string tgNamespace = _table.Namespace;
                while (Common.ADP.IsEmpty(tgNamespace)) {
                    DataRelation [] nestedParentRelations = _table.NestedParentRelations;
                    if (nestedParentRelations.Length == 0){
                        tgNamespace = (_ds != null) ?_ds.Namespace : "";
                        break;
                    }
                    int nestedparentPosition = -1; // it is find non-self-nested-parent
                    for(int i = 0; i < nestedParentRelations.Length; i++) {
                        if (nestedParentRelations[i].ParentTable != _table) {
                            nestedparentPosition = i;
                            break;
                        }
                    }
                    if (nestedparentPosition == -1) {
                        break;
                    }
                    else {
                        _table = nestedParentRelations[nestedparentPosition].ParentTable;
                    }
                    tgNamespace = _table.Namespace;
                }

                if (table.Namespace != tgNamespace) {
                    root.SetAttribute( Keywords.FORM, Keywords.UNQUALIFIED);
                    fUnqualified = true;
                }

            }


            if (table.ShouldSerializeCaseSensitive()) {
                root.SetAttribute(Keywords.MSD_CASESENSITIVE, Keywords.MSDNS, table.CaseSensitive.ToString(CultureInfo.InvariantCulture));
            }
            if (table.ShouldSerializeLocale()) {
                root.SetAttribute(Keywords.MSD_LOCALE, Keywords.MSDNS, table.Locale.ToString());
            }

            AddXdoProperties(table, root, dc);

            DataColumnCollection columns = table.Columns;

            int cCount = columns.Count;
            int realCount = 0;

            if (cCount ==1 || cCount ==2)
                for (int i = 0; i < cCount; i++) {
                    DataColumn col = columns[i];

                    if (col.ColumnMapping == MappingType.Hidden) {
                        DataRelationCollection childRelations = table.ChildRelations;
                        for (int j = 0; j < childRelations.Count; j++) {
                            if (childRelations[j].Nested && childRelations[j].ParentKey.ColumnsReference.Length == 1 && childRelations[j].ParentKey.ColumnsReference[0] == col)
                                    realCount++;
                        }
                    }

                    if (col.ColumnMapping == MappingType.Element)
                        realCount++;
                }


            if ((table.repeatableElement) && (realCount ==1)) {
                // I only have 1 column and that gives me
                // the type for this element
                DataColumn col = table.Columns[0];
                string _typeName = XmlDataTypeName(col.DataType);
                if (_typeName == null || _typeName.Length == 0) {
                    _typeName = Keywords.XSD_ANYTYPE;
                }

                root.SetAttribute(Keywords.TYPE, XSDSchema.QualifiedName(_typeName));
                return root;
            }

            // Now add the type information nested inside the element or global.
            XmlElement type = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_COMPLEXTYPE, Keywords.XSDNS);

            if (!table.TypeName.IsEmpty && schFormat != SchemaFormat.Remoting) {
                XmlElement typeSchema = GetSchema(table.TypeName.Namespace);
                if (Common.ADP.IsEmpty(table.TypeName.Namespace)) {
                    if (_ds == null)
                        typeSchema = GetSchema(table.Namespace);
                    else
                        typeSchema = fUnqualified ? GetSchema(_ds.Namespace): GetSchema(table.Namespace);
                }

                if (FindTypeNode(typeSchema, table.TypeName.Name) == null)
                    typeSchema.AppendChild(type);

                type.SetAttribute(Keywords.NAME, table.TypeName.Name);
            }
            else {
                root.AppendChild(type);
            }

            if (!table.TypeName.IsEmpty) {
                if (schFormat != SchemaFormat.Remoting)
                    root.SetAttribute( Keywords.TYPE, NewDiffgramGen.QualifiedName((string)prefixes[table.TypeName.Namespace], table.TypeName.Name) );
// Bug 108292: Since we always write complex type as annonymous type, DO NOT WRITE ITS NAME
//  DO NOT REVERT THIS CHANGE
            }

            XmlElement compositor = null;

            DataColumn colTxt = table.XmlText;

            if (colTxt != null) {
                XmlElement sc = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_SIMPLECONTENT , Keywords.XSDNS);

                if (colTxt.GetType() != typeof(DataColumn))
                    AddXdoProperties(colTxt, sc, dc);
                else
                    AddColumnProperties(colTxt, sc);
                AddExtendedProperties(colTxt.extendedProperties, sc);

                 if (colTxt.AllowDBNull)
                     root.SetAttribute(Keywords.XSD_NILLABLE, String.Empty, Keywords.TRUE);
                if (!colTxt.DefaultValueIsNull) 
                {
                    XmlTreeGen.ValidateColumnMapping(colTxt.DataType);
                    sc.SetAttribute(Keywords.MSD_DEFAULTVALUE, Keywords.MSDNS, colTxt.ConvertObjectToXml(colTxt.DefaultValue));
                }

                sc.SetAttribute(Keywords.MSD_COLUMNNAME, Keywords.MSDNS, colTxt.ColumnName);
                sc.SetAttribute(Keywords.MSD_ORDINAL, Keywords.MSDNS, colTxt.Ordinal.ToString(CultureInfo.InvariantCulture));

                type.AppendChild (sc);
                XmlElement ext = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_EXTENSION, Keywords.XSDNS);
                sc.AppendChild(ext);
                HandleColumnType(colTxt, dc, ext, schema);
                type = ext;
            }

            compositor = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_SEQUENCE, Keywords.XSDNS);
            type.AppendChild(compositor);

            fWriteOrdinals = HasMixedColumns(table);

            for (int i = 0; i < cCount; i++) {
                DataColumn col = columns[i];

                if (col.ColumnMapping == MappingType.SimpleContent)
                    continue;

                if (col.ColumnMapping == MappingType.Attribute || col.ColumnMapping == MappingType.Element || col.ColumnMapping == MappingType.Hidden ) {
                    if (IsAutoGenerated(col)) // skip automanifactured columns
                        continue;
                    bool isAttribute = col.ColumnMapping != MappingType.Element;
                    XmlElement el = HandleColumn(col, dc, schema, fWriteOrdinals);

                    XmlElement node = isAttribute ? type : compositor;
                    //bool flag = isAttribute ? col.Namespace == "" : col.Namespace == table.Namespace;
                    node.AppendChild(el);
                }
            }

            if ((table.XmlText == null) && (genNested)) {

                DataRelationCollection childRelations = table.ChildRelations;

                for (int j = 0; j < childRelations.Count; j++) {
                    XmlElement NestedTable;

                    if (!childRelations[j].Nested)
                        continue;

                    DataTable childTable = childRelations[j].ChildTable;

                    if (childTable == table) { // self join
                        NestedTable = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_ELEMENT, Keywords.XSDNS);

                        NestedTable.SetAttribute( Keywords.REF, table.EncodedTableName );
                    }
                    else if (childTable.NestedParentsCount >1 ) { // skip relations with multiple parents
                        NestedTable = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_ELEMENT, Keywords.XSDNS);
                        NestedTable.SetAttribute( Keywords.REF, childTable.EncodedTableName);
                    }
                    else
                        NestedTable = HandleTable(childTable, dc, schema);

                    if (childTable.Namespace == table.Namespace) {
                        NestedTable.SetAttribute(Keywords.MINOCCURS , "0");
                        NestedTable.SetAttribute(Keywords.MAXOCCURS , Keywords.ZERO_OR_MORE);
                    }

                    if ((childTable.Namespace == table.Namespace) || (childTable.Namespace.Length == 0) || schFormat == SchemaFormat.Remoting) {
                        compositor.AppendChild(NestedTable);
                    }
                    else {
                        if (childTable.NestedParentsCount <= 1 )
                            GetSchema(childTable.Namespace).AppendChild(NestedTable);
                        NestedTable = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_ELEMENT, Keywords.XSDNS);
                        NestedTable.SetAttribute( Keywords.REF, ((string)prefixes[childTable.Namespace])+':'+childTable.EncodedTableName);
                        compositor.AppendChild(NestedTable);
                    }

                    if (childRelations[j].ChildKeyConstraint != null)
                        continue; // we write the relation using the constraint

                    XmlElement nodeAnn = _dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_ANNOTATION, Keywords.XSDNS);
                    NestedTable.PrependChild(nodeAnn);

                    XmlElement nodeApp = _dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_APPINFO, Keywords.XSDNS);
                    nodeAnn.AppendChild(nodeApp);

                    nodeApp.AppendChild(HandleRelation(childRelations[j], dc));

                }

            }

            if (compositor != null)
                if (!compositor.HasChildNodes)
                    type.RemoveChild(compositor);

            // Output all constraints.


            ConstraintCollection constraints = table.Constraints;
            XmlElement selector, field;
            String xpathprefix = (_ds != null)? (_ds.Namespace.Length != 0 ? Keywords.MSTNS_PREFIX : String.Empty) : String.Empty;
            if (schFormat != SchemaFormat.Remoting) {
                GetSchema(table.Namespace); // to ensure prefix handling
                xpathprefix = table.Namespace.Length != 0 ? (string) prefixes[table.Namespace] +':' : String.Empty;
            }

            for (int i = 0; i < constraints.Count; i++) {
                XmlElement constraint = null;
                DataColumn[] fields;

                if (constraints[i] is UniqueConstraint) {

                    UniqueConstraint unique = (UniqueConstraint)constraints[i];

                    if (IsAutoGenerated(unique))
                        continue;

                    // special case of the ghosted constraints:
                    fields = unique.Key.ColumnsReference;


                    constraint = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_UNIQUE, Keywords.XSDNS);

                    if ((_ds == null) || (_ds.Tables.InternalIndexOf(table.TableName) ==-3))
                        constraint.SetAttribute( Keywords.MSD_TABLENS, Keywords.MSDNS, table.Namespace);
                    // convert constraint name to valid xml name
                    constraint.SetAttribute( Keywords.NAME, XmlConvert.EncodeLocalName( unique.SchemaName ));

                    if (unique.ConstraintName != unique.SchemaName)
                        constraint.SetAttribute(Keywords.MSD_CONSTRAINTNAME, Keywords.MSDNS, unique.ConstraintName);

                    AddExtendedProperties(unique.extendedProperties, constraint);


                    selector = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_SELECTOR, Keywords.XSDNS);
                    selector.SetAttribute(Keywords.XSD_XPATH, ".//"+xpathprefix+table.EncodedTableName);

                    constraint.AppendChild(selector);


                    if (unique.IsPrimaryKey) {
                        constraint.SetAttribute(Keywords.MSD_PRIMARYKEY, Keywords.MSDNS, Keywords.TRUE);
                    }

                    if (0 < fields.Length) {
                        StringBuilder encodedName = new StringBuilder();
                        for (int k = 0; k < fields.Length; k++) {
                            encodedName.Length = 0;

                            if (schFormat != SchemaFormat.Remoting) {
                                GetSchema(fields[k].Namespace);
                                if (!Common.ADP.IsEmpty(fields[k].Namespace)) {
                                    encodedName.Append(prefixes[fields[k].Namespace]).Append(':');
                                }
                                encodedName.Append(fields[k].EncodedColumnName);
                            }
                            else {
                                encodedName.Append(xpathprefix).Append(fields[k].EncodedColumnName);
                            }
                            if ((fields[k].ColumnMapping == MappingType.Attribute) || (fields[k].ColumnMapping == MappingType.Hidden)) {
                                encodedName.Insert(0, '@');
                            }
                            field = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_FIELD, Keywords.XSDNS);
                            field.SetAttribute(Keywords.XSD_XPATH, encodedName.ToString());

                            constraint.AppendChild(field);
                        }
                    }

                    dsElement.InsertBefore(constraint, constraintSeparator);
                }
                else if (constraints[i] is ForeignKeyConstraint && genNested) {
                    ForeignKeyConstraint foreign = (ForeignKeyConstraint)constraints[i];

                    if (_tables.Count > 0) {
                        if (!_tables.Contains(foreign.RelatedTable) || !_tables.Contains(foreign.Table))
                            continue;
                    }

                    if (IsAutoGenerated(foreign))
                        continue;


                    DataRelation rel = foreign.FindParentRelation();

                    // special case of the ghosted constraints:
                    fields = foreign.RelatedColumnsReference;


                    UniqueConstraint _constraint = (UniqueConstraint) foreign.RelatedTable.Constraints.FindConstraint( new UniqueConstraint( "TEMP", fields));

                    if (_constraint == null) {
                        constraint = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_KEY, Keywords.XSDNS);
                        constraint.SetAttribute( Keywords.NAME, XmlConvert.EncodeLocalName( foreign.SchemaName ));

                        if ((_ds == null) || (_ds.Tables.InternalIndexOf(table.TableName) ==-3))
                            constraint.SetAttribute( Keywords.MSD_TABLENS, Keywords.MSDNS, table.Namespace);

                        selector = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_SELECTOR, Keywords.XSDNS);
                        selector.SetAttribute(Keywords.XSD_XPATH, ".//"+xpathprefix+ foreign.RelatedTable.EncodedTableName);

                        constraint.AppendChild(selector);

                        if (0 < fields.Length) {
                            StringBuilder encodedName = new StringBuilder();
                            for (int k = 0; k < fields.Length; k++) {
                                encodedName.Length = 0;

                                if (schFormat != SchemaFormat.Remoting) {
                                    GetSchema(fields[k].Namespace);
                                    if (!Common.ADP.IsEmpty(fields[k].Namespace)) {
                                        encodedName.Append(prefixes[fields[k].Namespace]).Append(':');
                                    }
                                    encodedName.Append(fields[k].EncodedColumnName);
                                }
                                else {
                                    encodedName.Append(xpathprefix).Append(fields[k].EncodedColumnName);
                                }
                                if ((fields[k].ColumnMapping == MappingType.Attribute) || (fields[k].ColumnMapping == MappingType.Hidden)) {
                                    encodedName.Insert(0, '@');
                                }
                                field = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_FIELD, Keywords.XSDNS);
                                field.SetAttribute(Keywords.XSD_XPATH, encodedName.ToString());

                                constraint.AppendChild(field);
                            }
                        }

                        dsElement.InsertBefore(constraint, constraintSeparator);
                    }

                    constraint = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_KEYREF, Keywords.XSDNS);
                    // convert constraint name to valid xml name
                    constraint.SetAttribute( Keywords.NAME,XmlConvert.EncodeLocalName(  foreign.SchemaName ));

                    if ((_ds == null) || (_ds.Tables.InternalIndexOf(foreign.RelatedTable.TableName) == -3)) // if there is a conflicting name/namespace only
                        constraint.SetAttribute (Keywords.MSD_TABLENS,  Keywords.MSDNS, foreign.Table.Namespace);

                    if (_constraint == null)
                        constraint.SetAttribute( Keywords.REFER, XmlConvert.EncodeLocalName( foreign.SchemaName ));
                    else
                        constraint.SetAttribute( Keywords.REFER, XmlConvert.EncodeLocalName( _constraint.SchemaName ));

                    AddExtendedProperties(foreign.extendedProperties, constraint, typeof(ForeignKeyConstraint));

                    if (foreign.ConstraintName != foreign.SchemaName)
                        constraint.SetAttribute(Keywords.MSD_CONSTRAINTNAME, Keywords.MSDNS, foreign.ConstraintName);

                    if (null == rel) {
                        constraint.SetAttribute(Keywords.MSD_CONSTRAINTONLY , Keywords.MSDNS, Keywords.TRUE );
                    }else {
                        if (rel.Nested)
                            constraint.SetAttribute(Keywords.MSD_ISNESTED, Keywords.MSDNS, Keywords.TRUE);

                        AddExtendedProperties(rel.extendedProperties, constraint, typeof(DataRelation));
                        if (foreign.ConstraintName != rel.RelationName) {
                            constraint.SetAttribute( Keywords.MSD_RELATIONNAME , Keywords.MSDNS, XmlConvert.EncodeLocalName( rel.RelationName ));
                        }
                    }

                    selector = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_SELECTOR, Keywords.XSDNS);
                    selector.SetAttribute(Keywords.XSD_XPATH, ".//"+xpathprefix+table.EncodedTableName);

                    constraint.AppendChild(selector);

                    if (foreign.AcceptRejectRule != ForeignKeyConstraint.AcceptRejectRule_Default)
                        constraint.SetAttribute(Keywords.MSD_ACCEPTREJECTRULE, Keywords.MSDNS,
                                                TranslateAcceptRejectRule(foreign.AcceptRejectRule) );

                    if (foreign.UpdateRule != ForeignKeyConstraint.Rule_Default)
                        constraint.SetAttribute( Keywords.MSD_UPDATERULE, Keywords.MSDNS, TranslateRule(foreign.UpdateRule) );

                    if (foreign.DeleteRule != ForeignKeyConstraint.Rule_Default)
                        constraint.SetAttribute( Keywords.MSD_DELETERULE, Keywords.MSDNS, TranslateRule(foreign.DeleteRule) );

                    fields = foreign.Columns;

                    if (0 < fields.Length) {
                        StringBuilder encodedName = new StringBuilder();
                        for (int k = 0; k < fields.Length; k++) {
                            encodedName.Length = 0;

                            if (schFormat != SchemaFormat.Remoting) {
                                GetSchema(fields[k].Namespace);
                                if (!Common.ADP.IsEmpty(fields[k].Namespace)) {
                                    encodedName.Append(prefixes[fields[k].Namespace]).Append(':');
                                }
                                encodedName.Append(fields[k].EncodedColumnName);
                            }
                            else {
                                encodedName.Append(xpathprefix).Append(fields[k].EncodedColumnName);
                            }
                            if ((fields[k].ColumnMapping == MappingType.Attribute) || (fields[k].ColumnMapping == MappingType.Hidden)) {
                                encodedName.Insert(0, '@');
                            }
                            field = dc.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_FIELD, Keywords.XSDNS);
                            field.SetAttribute(Keywords.XSD_XPATH, encodedName.ToString());

                            constraint.AppendChild(field);
                        }
                    }

                    dsElement.InsertAfter(constraint, constraintSeparator);
                }
            }

            AddExtendedProperties(table.extendedProperties, root);
            return root;
        }
 internal XmlElement HandleTable(DataTable table, XmlDocument dc, XmlElement schema, bool genNested)
 {
     XmlElement root = dc.CreateElement("xs", "element", "http://www.w3.org/2001/XMLSchema");
     bool fWriteOrdinal = false;
     bool flag = false;
     if (((table.DataSet == null) || ((this._ds != null) && (table.Namespace != this._ds.Namespace))) && (this.schFormat == SchemaFormat.Remoting))
     {
         root.SetAttribute("targetNamespace", "urn:schemas-microsoft-com:xml-msdata", table.Namespace);
     }
     root.SetAttribute("name", table.EncodedTableName);
     if (table.Namespace.Length == 0)
     {
         DataTable parentTable = table;
         string str3 = parentTable.Namespace;
         while (ADP.IsEmpty(str3))
         {
             DataRelation[] nestedParentRelations = parentTable.NestedParentRelations;
             if (nestedParentRelations.Length == 0)
             {
                 str3 = (this._ds != null) ? this._ds.Namespace : "";
                 break;
             }
             int index = -1;
             for (int k = 0; k < nestedParentRelations.Length; k++)
             {
                 if (nestedParentRelations[k].ParentTable != parentTable)
                 {
                     index = k;
                     break;
                 }
             }
             if (index == -1)
             {
                 break;
             }
             parentTable = nestedParentRelations[index].ParentTable;
             str3 = parentTable.Namespace;
         }
         if (table.Namespace != str3)
         {
             root.SetAttribute("form", "unqualified");
             flag = true;
         }
     }
     if (table.ShouldSerializeCaseSensitive())
     {
         root.SetAttribute("CaseSensitive", "urn:schemas-microsoft-com:xml-msdata", table.CaseSensitive.ToString(CultureInfo.InvariantCulture));
     }
     if (table.ShouldSerializeLocale())
     {
         root.SetAttribute("Locale", "urn:schemas-microsoft-com:xml-msdata", table.Locale.ToString());
     }
     this.AddXdoProperties(table, root, dc);
     DataColumnCollection columns = table.Columns;
     int count = columns.Count;
     int num7 = 0;
     switch (count)
     {
         case 1:
         case 2:
             for (int m = 0; m < count; m++)
             {
                 DataColumn column3 = columns[m];
                 if (column3.ColumnMapping == MappingType.Hidden)
                 {
                     DataRelationCollection childRelations = table.ChildRelations;
                     for (int n = 0; n < childRelations.Count; n++)
                     {
                         if ((childRelations[n].Nested && (childRelations[n].ParentKey.ColumnsReference.Length == 1)) && (childRelations[n].ParentKey.ColumnsReference[0] == column3))
                         {
                             num7++;
                         }
                     }
                 }
                 if (column3.ColumnMapping == MappingType.Element)
                 {
                     num7++;
                 }
             }
             break;
     }
     if (table.repeatableElement && (num7 == 1))
     {
         DataColumn column4 = table.Columns[0];
         string name = XmlDataTypeName(column4.DataType);
         if ((name == null) || (name.Length == 0))
         {
             name = "anyType";
         }
         root.SetAttribute("type", XSDSchema.QualifiedName(name));
         return root;
     }
     XmlElement newChild = dc.CreateElement("xs", "complexType", "http://www.w3.org/2001/XMLSchema");
     if (!table.TypeName.IsEmpty && (this.schFormat != SchemaFormat.Remoting))
     {
         XmlElement node = this.GetSchema(table.TypeName.Namespace);
         if (ADP.IsEmpty(table.TypeName.Namespace))
         {
             if (this._ds == null)
             {
                 node = this.GetSchema(table.Namespace);
             }
             else
             {
                 node = flag ? this.GetSchema(this._ds.Namespace) : this.GetSchema(table.Namespace);
             }
         }
         if (this.FindTypeNode(node, table.TypeName.Name) == null)
         {
             node.AppendChild(newChild);
         }
         newChild.SetAttribute("name", table.TypeName.Name);
     }
     else
     {
         root.AppendChild(newChild);
     }
     if (!table.TypeName.IsEmpty && (this.schFormat != SchemaFormat.Remoting))
     {
         root.SetAttribute("type", NewDiffgramGen.QualifiedName((string) this.prefixes[table.TypeName.Namespace], table.TypeName.Name));
     }
     XmlElement element7 = null;
     DataColumn xmlText = table.XmlText;
     if (xmlText != null)
     {
         XmlElement element6 = dc.CreateElement("xs", "simpleContent", "http://www.w3.org/2001/XMLSchema");
         if (xmlText.GetType() != typeof(DataColumn))
         {
             this.AddXdoProperties(xmlText, element6, dc);
         }
         else
         {
             this.AddColumnProperties(xmlText, element6);
         }
         AddExtendedProperties(xmlText.extendedProperties, element6);
         if (xmlText.AllowDBNull)
         {
             root.SetAttribute("nillable", string.Empty, "true");
         }
         if (!xmlText.DefaultValueIsNull)
         {
             ValidateColumnMapping(xmlText.DataType);
             element6.SetAttribute("DefaultValue", "urn:schemas-microsoft-com:xml-msdata", xmlText.ConvertObjectToXml(xmlText.DefaultValue));
         }
         element6.SetAttribute("ColumnName", "urn:schemas-microsoft-com:xml-msdata", xmlText.ColumnName);
         element6.SetAttribute("Ordinal", "urn:schemas-microsoft-com:xml-msdata", xmlText.Ordinal.ToString(CultureInfo.InvariantCulture));
         newChild.AppendChild(element6);
         XmlElement element10 = dc.CreateElement("xs", "extension", "http://www.w3.org/2001/XMLSchema");
         element6.AppendChild(element10);
         this.HandleColumnType(xmlText, dc, element10, schema);
         newChild = element10;
     }
     element7 = dc.CreateElement("xs", "sequence", "http://www.w3.org/2001/XMLSchema");
     newChild.AppendChild(element7);
     fWriteOrdinal = this.HasMixedColumns(table);
     for (int i = 0; i < count; i++)
     {
         DataColumn o = columns[i];
         if (((o.ColumnMapping != MappingType.SimpleContent) && (((o.ColumnMapping == MappingType.Attribute) || (o.ColumnMapping == MappingType.Element)) || (o.ColumnMapping == MappingType.Hidden))) && !this.IsAutoGenerated(o))
         {
             bool flag3 = o.ColumnMapping != MappingType.Element;
             XmlElement element14 = this.HandleColumn(o, dc, schema, fWriteOrdinal);
             (flag3 ? newChild : element7).AppendChild(element14);
         }
     }
     if ((table.XmlText == null) && genNested)
     {
         DataRelationCollection relations = table.ChildRelations;
         for (int num5 = 0; num5 < relations.Count; num5++)
         {
             if (relations[num5].Nested)
             {
                 XmlElement element3;
                 DataTable childTable = relations[num5].ChildTable;
                 if (childTable == table)
                 {
                     element3 = dc.CreateElement("xs", "element", "http://www.w3.org/2001/XMLSchema");
                     element3.SetAttribute("ref", table.EncodedTableName);
                 }
                 else if (childTable.NestedParentsCount > 1)
                 {
                     element3 = dc.CreateElement("xs", "element", "http://www.w3.org/2001/XMLSchema");
                     element3.SetAttribute("ref", childTable.EncodedTableName);
                 }
                 else
                 {
                     element3 = this.HandleTable(childTable, dc, schema);
                 }
                 if (childTable.Namespace == table.Namespace)
                 {
                     element3.SetAttribute("minOccurs", "0");
                     element3.SetAttribute("maxOccurs", "unbounded");
                 }
                 if (((childTable.Namespace == table.Namespace) || (childTable.Namespace.Length == 0)) || (this.schFormat == SchemaFormat.Remoting))
                 {
                     element7.AppendChild(element3);
                 }
                 else
                 {
                     if (childTable.NestedParentsCount <= 1)
                     {
                         this.GetSchema(childTable.Namespace).AppendChild(element3);
                     }
                     element3 = dc.CreateElement("xs", "element", "http://www.w3.org/2001/XMLSchema");
                     element3.SetAttribute("ref", ((string) this.prefixes[childTable.Namespace]) + ':' + childTable.EncodedTableName);
                     element7.AppendChild(element3);
                 }
                 if (relations[num5].ChildKeyConstraint == null)
                 {
                     XmlElement element12 = this._dc.CreateElement("xs", "annotation", "http://www.w3.org/2001/XMLSchema");
                     element3.PrependChild(element12);
                     XmlElement element11 = this._dc.CreateElement("xs", "appinfo", "http://www.w3.org/2001/XMLSchema");
                     element12.AppendChild(element11);
                     element11.AppendChild(this.HandleRelation(relations[num5], dc));
                 }
             }
         }
     }
     if ((element7 != null) && !element7.HasChildNodes)
     {
         newChild.RemoveChild(element7);
     }
     ConstraintCollection constraints = table.Constraints;
     string str = (this._ds != null) ? ((this._ds.Namespace.Length != 0) ? "mstns:" : string.Empty) : string.Empty;
     if (this.schFormat != SchemaFormat.Remoting)
     {
         this.GetSchema(table.Namespace);
         str = (table.Namespace.Length != 0) ? (((string) this.prefixes[table.Namespace]) + ':') : string.Empty;
     }
     for (int j = 0; j < constraints.Count; j++)
     {
         DataColumn[] columnsReference;
         XmlElement element4;
         XmlElement element5;
         XmlElement element = null;
         if (constraints[j] is UniqueConstraint)
         {
             UniqueConstraint constraint2 = (UniqueConstraint) constraints[j];
             if (!this.IsAutoGenerated(constraint2))
             {
                 columnsReference = constraint2.Key.ColumnsReference;
                 element = dc.CreateElement("xs", "unique", "http://www.w3.org/2001/XMLSchema");
                 if ((this._ds == null) || (this._ds.Tables.InternalIndexOf(table.TableName) == -3))
                 {
                     element.SetAttribute("TableNamespace", "urn:schemas-microsoft-com:xml-msdata", table.Namespace);
                 }
                 element.SetAttribute("name", XmlConvert.EncodeLocalName(constraint2.SchemaName));
                 if (constraint2.ConstraintName != constraint2.SchemaName)
                 {
                     element.SetAttribute("ConstraintName", "urn:schemas-microsoft-com:xml-msdata", constraint2.ConstraintName);
                 }
                 AddExtendedProperties(constraint2.extendedProperties, element);
                 element5 = dc.CreateElement("xs", "selector", "http://www.w3.org/2001/XMLSchema");
                 element5.SetAttribute("xpath", ".//" + str + table.EncodedTableName);
                 element.AppendChild(element5);
                 if (constraint2.IsPrimaryKey)
                 {
                     element.SetAttribute("PrimaryKey", "urn:schemas-microsoft-com:xml-msdata", "true");
                 }
                 if (0 < columnsReference.Length)
                 {
                     StringBuilder builder3 = new StringBuilder();
                     for (int num3 = 0; num3 < columnsReference.Length; num3++)
                     {
                         builder3.Length = 0;
                         if (this.schFormat != SchemaFormat.Remoting)
                         {
                             this.GetSchema(columnsReference[num3].Namespace);
                             if (!ADP.IsEmpty(columnsReference[num3].Namespace))
                             {
                                 builder3.Append(this.prefixes[columnsReference[num3].Namespace]).Append(':');
                             }
                             builder3.Append(columnsReference[num3].EncodedColumnName);
                         }
                         else
                         {
                             builder3.Append(str).Append(columnsReference[num3].EncodedColumnName);
                         }
                         if ((columnsReference[num3].ColumnMapping == MappingType.Attribute) || (columnsReference[num3].ColumnMapping == MappingType.Hidden))
                         {
                             builder3.Insert(0, '@');
                         }
                         element4 = dc.CreateElement("xs", "field", "http://www.w3.org/2001/XMLSchema");
                         element4.SetAttribute("xpath", builder3.ToString());
                         element.AppendChild(element4);
                     }
                 }
                 this.dsElement.InsertBefore(element, this.constraintSeparator);
             }
         }
         else if ((constraints[j] is ForeignKeyConstraint) && genNested)
         {
             ForeignKeyConstraint constraint = (ForeignKeyConstraint) constraints[j];
             if (((this._tables.Count <= 0) || (this._tables.Contains(constraint.RelatedTable) && this._tables.Contains(constraint.Table))) && !this.IsAutoGenerated(constraint))
             {
                 DataRelation relation = constraint.FindParentRelation();
                 columnsReference = constraint.RelatedColumnsReference;
                 UniqueConstraint constraint3 = (UniqueConstraint) constraint.RelatedTable.Constraints.FindConstraint(new UniqueConstraint("TEMP", columnsReference));
                 if (constraint3 == null)
                 {
                     element = dc.CreateElement("xs", "key", "http://www.w3.org/2001/XMLSchema");
                     element.SetAttribute("name", XmlConvert.EncodeLocalName(constraint.SchemaName));
                     if ((this._ds == null) || (this._ds.Tables.InternalIndexOf(table.TableName) == -3))
                     {
                         element.SetAttribute("TableNamespace", "urn:schemas-microsoft-com:xml-msdata", table.Namespace);
                     }
                     element5 = dc.CreateElement("xs", "selector", "http://www.w3.org/2001/XMLSchema");
                     element5.SetAttribute("xpath", ".//" + str + constraint.RelatedTable.EncodedTableName);
                     element.AppendChild(element5);
                     if (0 < columnsReference.Length)
                     {
                         StringBuilder builder2 = new StringBuilder();
                         for (int num2 = 0; num2 < columnsReference.Length; num2++)
                         {
                             builder2.Length = 0;
                             if (this.schFormat != SchemaFormat.Remoting)
                             {
                                 this.GetSchema(columnsReference[num2].Namespace);
                                 if (!ADP.IsEmpty(columnsReference[num2].Namespace))
                                 {
                                     builder2.Append(this.prefixes[columnsReference[num2].Namespace]).Append(':');
                                 }
                                 builder2.Append(columnsReference[num2].EncodedColumnName);
                             }
                             else
                             {
                                 builder2.Append(str).Append(columnsReference[num2].EncodedColumnName);
                             }
                             if ((columnsReference[num2].ColumnMapping == MappingType.Attribute) || (columnsReference[num2].ColumnMapping == MappingType.Hidden))
                             {
                                 builder2.Insert(0, '@');
                             }
                             element4 = dc.CreateElement("xs", "field", "http://www.w3.org/2001/XMLSchema");
                             element4.SetAttribute("xpath", builder2.ToString());
                             element.AppendChild(element4);
                         }
                     }
                     this.dsElement.InsertBefore(element, this.constraintSeparator);
                 }
                 element = dc.CreateElement("xs", "keyref", "http://www.w3.org/2001/XMLSchema");
                 element.SetAttribute("name", XmlConvert.EncodeLocalName(constraint.SchemaName));
                 if ((this._ds == null) || (this._ds.Tables.InternalIndexOf(constraint.RelatedTable.TableName) == -3))
                 {
                     element.SetAttribute("TableNamespace", "urn:schemas-microsoft-com:xml-msdata", constraint.Table.Namespace);
                 }
                 if (constraint3 == null)
                 {
                     element.SetAttribute("refer", XmlConvert.EncodeLocalName(constraint.SchemaName));
                 }
                 else
                 {
                     element.SetAttribute("refer", XmlConvert.EncodeLocalName(constraint3.SchemaName));
                 }
                 AddExtendedProperties(constraint.extendedProperties, element, typeof(ForeignKeyConstraint));
                 if (constraint.ConstraintName != constraint.SchemaName)
                 {
                     element.SetAttribute("ConstraintName", "urn:schemas-microsoft-com:xml-msdata", constraint.ConstraintName);
                 }
                 if (relation == null)
                 {
                     element.SetAttribute("ConstraintOnly", "urn:schemas-microsoft-com:xml-msdata", "true");
                 }
                 else
                 {
                     if (relation.Nested)
                     {
                         element.SetAttribute("IsNested", "urn:schemas-microsoft-com:xml-msdata", "true");
                     }
                     AddExtendedProperties(relation.extendedProperties, element, typeof(DataRelation));
                     if (constraint.ConstraintName != relation.RelationName)
                     {
                         element.SetAttribute("RelationName", "urn:schemas-microsoft-com:xml-msdata", XmlConvert.EncodeLocalName(relation.RelationName));
                     }
                 }
                 element5 = dc.CreateElement("xs", "selector", "http://www.w3.org/2001/XMLSchema");
                 element5.SetAttribute("xpath", ".//" + str + table.EncodedTableName);
                 element.AppendChild(element5);
                 if (constraint.AcceptRejectRule != AcceptRejectRule.None)
                 {
                     element.SetAttribute("AcceptRejectRule", "urn:schemas-microsoft-com:xml-msdata", TranslateAcceptRejectRule(constraint.AcceptRejectRule));
                 }
                 if (constraint.UpdateRule != Rule.Cascade)
                 {
                     element.SetAttribute("UpdateRule", "urn:schemas-microsoft-com:xml-msdata", TranslateRule(constraint.UpdateRule));
                 }
                 if (constraint.DeleteRule != Rule.Cascade)
                 {
                     element.SetAttribute("DeleteRule", "urn:schemas-microsoft-com:xml-msdata", TranslateRule(constraint.DeleteRule));
                 }
                 columnsReference = constraint.Columns;
                 if (0 < columnsReference.Length)
                 {
                     StringBuilder builder = new StringBuilder();
                     for (int num = 0; num < columnsReference.Length; num++)
                     {
                         builder.Length = 0;
                         if (this.schFormat != SchemaFormat.Remoting)
                         {
                             this.GetSchema(columnsReference[num].Namespace);
                             if (!ADP.IsEmpty(columnsReference[num].Namespace))
                             {
                                 builder.Append(this.prefixes[columnsReference[num].Namespace]).Append(':');
                             }
                             builder.Append(columnsReference[num].EncodedColumnName);
                         }
                         else
                         {
                             builder.Append(str).Append(columnsReference[num].EncodedColumnName);
                         }
                         if ((columnsReference[num].ColumnMapping == MappingType.Attribute) || (columnsReference[num].ColumnMapping == MappingType.Hidden))
                         {
                             builder.Insert(0, '@');
                         }
                         element4 = dc.CreateElement("xs", "field", "http://www.w3.org/2001/XMLSchema");
                         element4.SetAttribute("xpath", builder.ToString());
                         element.AppendChild(element4);
                     }
                 }
                 this.dsElement.InsertAfter(element, this.constraintSeparator);
             }
         }
     }
     AddExtendedProperties(table.extendedProperties, root);
     return root;
 }
 internal XmlElement FillDataSetElement(XmlDocument xd, DataSet ds, DataTable dt)
 {
     DataSet set = (ds != null) ? ds : dt.DataSet;
     if (set != null)
     {
         this.dsElement.SetAttribute("name", XmlConvert.EncodeLocalName(set.DataSetName));
         this.dsElement.SetAttribute("IsDataSet", "urn:schemas-microsoft-com:xml-msdata", "true");
         if (ds == null)
         {
             this.dsElement.SetAttribute("MainDataTable", "urn:schemas-microsoft-com:xml-msdata", XmlConvert.EncodeLocalName((dt.Namespace.Length == 0) ? dt.TableName : (dt.Namespace + ":" + dt.TableName)));
         }
         if (set.CaseSensitive)
         {
             this.dsElement.SetAttribute("CaseSensitive", "urn:schemas-microsoft-com:xml-msdata", "true");
         }
         if (set.ShouldSerializeLocale() || !set.Locale.Equals(CultureInfo.CurrentCulture))
         {
             this.dsElement.SetAttribute("Locale", "urn:schemas-microsoft-com:xml-msdata", set.Locale.ToString());
         }
         else
         {
             this.dsElement.SetAttribute("UseCurrentLocale", "urn:schemas-microsoft-com:xml-msdata", "true");
         }
     }
     else if (dt != null)
     {
         this.dsElement.SetAttribute("name", XmlConvert.EncodeLocalName("NewDataSet"));
         this.dsElement.SetAttribute("IsDataSet", "urn:schemas-microsoft-com:xml-msdata", "true");
         this.dsElement.SetAttribute("MainDataTable", "urn:schemas-microsoft-com:xml-msdata", XmlConvert.EncodeLocalName((dt.Namespace.Length == 0) ? dt.TableName : (dt.Namespace + ":" + dt.TableName)));
         if (dt.CaseSensitive)
         {
             this.dsElement.SetAttribute("CaseSensitive", "urn:schemas-microsoft-com:xml-msdata", "true");
         }
         if (dt.ShouldSerializeLocale() || !dt.Locale.Equals(CultureInfo.CurrentCulture))
         {
             this.dsElement.SetAttribute("Locale", "urn:schemas-microsoft-com:xml-msdata", dt.Locale.ToString());
         }
         else
         {
             this.dsElement.SetAttribute("UseCurrentLocale", "urn:schemas-microsoft-com:xml-msdata", "true");
         }
     }
     XmlElement newChild = xd.CreateElement("xs", "complexType", "http://www.w3.org/2001/XMLSchema");
     this.dsElement.AppendChild(newChild);
     XmlElement element = xd.CreateElement("xs", "choice", "http://www.w3.org/2001/XMLSchema");
     element.SetAttribute("minOccurs", "0");
     element.SetAttribute("maxOccurs", "unbounded");
     newChild.AppendChild(element);
     return element;
 }
Beispiel #5
0
        }// CreateOnRowEventMethod

        private CodeTypeDeclaration CreateTypedTable(DataTable table) {
            string stRowClassName = RowClassName(table);
            string stTblClassName = TableClassName(table);
            string stRowConcreateClassName = RowConcreteClassName(table);

            CodeTypeDeclaration dataTableClass = new CodeTypeDeclaration(stTblClassName);
            dataTableClass.BaseTypes.Add(typeof(DataTable));
            dataTableClass.BaseTypes.Add(typeof(System.Collections.IEnumerable));
            //dataTableClass.Attributes |= TypeAttributes.NestedPrivate;

            dataTableClass.CustomAttributes.Add(AttributeDecl("System.Serializable"));
            dataTableClass.CustomAttributes.Add(AttributeDecl("System.Diagnostics.DebuggerStepThrough"));

            for (int i = 0; i < table.Columns.Count; i++) {
                //\\ DataColumn column<ColumnName>;
                dataTableClass.Members.Add(FieldDecl(typeof(DataColumn), TableColumnFieldName(table.Columns[i])));
            }              

            dataTableClass.Members.Add(EventDecl(stRowClassName + "ChangeEventHandler", stRowClassName + "Changed" ));
            dataTableClass.Members.Add(EventDecl(stRowClassName + "ChangeEventHandler", stRowClassName + "Changing"));
            dataTableClass.Members.Add(EventDecl(stRowClassName + "ChangeEventHandler", stRowClassName + "Deleted" ));
            dataTableClass.Members.Add(EventDecl(stRowClassName + "ChangeEventHandler", stRowClassName + "Deleting"));

            //\\ internal <TableName>DataTableClass() : base("<TableName>") {
            //\\     this.InitClass();
            //\\ }
            CodeConstructor constructor = new CodeConstructor(); {
                constructor.Attributes = MemberAttributes.Assembly | MemberAttributes.Final;
                constructor.BaseConstructorArgs.Add(Str(table.TableName));
                constructor.Statements.Add(MethodCall(This(), "InitClass"));
            }
            dataTableClass.Members.Add(constructor);
            //\\ protected <TableName>DataTableClass("<info>,<context>") : base("<info>,<context>") {
            //\\    InitVars();
            //\\ }           
            constructor = new CodeConstructor(); {
                constructor.Attributes = MemberAttributes.Family;
                constructor.Parameters.Add(ParameterDecl(typeof(System.Runtime.Serialization.SerializationInfo), "info" ));
                constructor.Parameters.Add(ParameterDecl(typeof(System.Runtime.Serialization.StreamingContext), "context"));
                constructor.BaseConstructorArgs.AddRange(new CodeExpression[] {Argument("info"), Argument("context")});
                constructor.Statements.Add(MethodCall(This(), "InitVars"));
            }
            dataTableClass.Members.Add(constructor);

            //\\ internal <TableName>DataTableClass(DataTable table) : base(table.TableName) { // Microsoft : Assuming incoming table always associated with DataSet
            //\\ if (table.CaseSensitive != table.DataSet.CaseSensitive)
            //\\    this.CaseSensitive = table.CaseSensitive;
            //\\ if (table.Locale.ToString() != table.DataSet.Locale.ToString())
            //\\    this.Locale = table.Locale;
            //\\ if (table.Namespace != table.DataSet.Namespace)
            //\\    this.Namespace = table.Namespace;
            //\\ this.Prefix = table.Prefix;
            //\\ this.MinimumCapacity = table.MinimumCapacity;
            //\\ this.DisplayExpression = table.DisplayExpression;
            //\\ }
                            constructor = new CodeConstructor(); {
                constructor.Attributes = MemberAttributes.Assembly | MemberAttributes.Final;
                constructor.Parameters.Add(ParameterDecl(typeof(DataTable), "table"));
                constructor.BaseConstructorArgs.Add(Property(Argument("table"),"TableName"));
                constructor.Statements.Add(
                    If(IdNotEQ(Property(Argument("table"),"CaseSensitive"),Property(Property(Argument("table"),"DataSet"),"CaseSensitive")),
                        Assign(Property(This(),"CaseSensitive"),Property(Argument("table"),"CaseSensitive"))
                    )
                );
                constructor.Statements.Add(
                    If(IdNotEQ(MethodCall(Property(Argument("table"),"Locale"),"ToString"),MethodCall(Property(Property(Argument("table"),"DataSet"),"Locale"),"ToString")),
                        Assign(Property(This(),"Locale"),Property(Argument("table"),"Locale"))
                    )
                );
                constructor.Statements.Add(
                    If(IdNotEQ(Property(Argument("table"),"Namespace"),Property(Property(Argument("table"),"DataSet"),"Namespace")),
                        Assign(Property(This(),"Namespace"),Property(Argument("table"),"Namespace"))
                    )
                );
                constructor.Statements.Add(Assign(Property(This(), "Prefix"), Property(Argument("table"),"Prefix")));
                constructor.Statements.Add(Assign(Property(This(), "MinimumCapacity"), Property(Argument("table"),"MinimumCapacity")));
                constructor.Statements.Add(Assign(Property(This(), "DisplayExpression"), Property(Argument("table"),"DisplayExpression")));
            }
            dataTableClass.Members.Add(constructor);

            //\\ public int Count {
            //\\     get { return this.Rows.Count; }
            //\\ }
            CodeMemberProperty countProp = PropertyDecl(typeof(System.Int32), "Count", MemberAttributes.Public | MemberAttributes.Final); {
                countProp.CustomAttributes.Add(AttributeDecl("System.ComponentModel.Browsable", Primitive(false)));
                countProp.GetStatements.Add(Return(Property(Property(This(), "Rows"), "Count")));
            }
            dataTableClass.Members.Add(countProp);

            for (int i = 0; i < table.Columns.Count; i++) {
                //\\ internal DataColumn NAMEColumn {
                //\\     get { return this.columnNAME; }
                //\\ }
                DataColumn column = table.Columns[i];
                CodeMemberProperty colProp = PropertyDecl(typeof(DataColumn), TableColumnPropertyName(column), MemberAttributes.Assembly | MemberAttributes.Final); {
                    colProp.GetStatements.Add(Return(Field(This(), TableColumnFieldName(column))));
                }
                dataTableClass.Members.Add(colProp);
            }

            //\\ public <RowClassName> this[int index] {
            //\\     return (<RowClassName>) this.Rows[index];
            //\\ }
            CodeMemberProperty thisIndex = PropertyDecl(stRowConcreateClassName, "Item", MemberAttributes.Public | MemberAttributes.Final); {
                thisIndex.Parameters.Add(ParameterDecl(typeof(Int32), "index"));
                thisIndex.GetStatements.Add(Return(Cast(stRowConcreateClassName, Indexer(Property(This(), "Rows"), Argument("index")))));
            }
            dataTableClass.Members.Add(thisIndex);

            //\\ public void Add<RowClassName>(<RowClassName>  row) {
            //\\     this.Rows.Add(row);
            //\\ }
            CodeMemberMethod addMethod = MethodDecl(typeof(void), "Add" + stRowClassName, MemberAttributes.Public | MemberAttributes.Final); {
                addMethod.Parameters.Add(ParameterDecl(stRowConcreateClassName, "row"));
                addMethod.Statements.Add(MethodCall(Property(This(), "Rows"), "Add", Argument("row")));
            }
            dataTableClass.Members.Add(addMethod);

            //\\ public <RowClassName> Add<RowClassName>(<ColType> <ColName>[, <ColType> <ColName> ...]) {
            //\\     <RowClassName> row;
            //\\     row = ((COMPUTERRow)(this.NewRow()));
            //\\     row.ItemArray = new Object[] {NAME, VERSION, null};
            //\\     this.Rows.Add(row);
            //\\     return row;
            //\\ }
            ArrayList parameterColumnList = new ArrayList();
            for (int i = 0; i < table.Columns.Count; i++) {
                if (!table.Columns[i].AutoIncrement) {
                    parameterColumnList.Add(table.Columns[i]);
                }
            }

            CodeMemberMethod addByColName = MethodDecl(stRowConcreateClassName, "Add" + stRowClassName, MemberAttributes.Public | MemberAttributes.Final); {
                DataColumn[] index = new DataColumn[parameterColumnList.Count];
                parameterColumnList.CopyTo(index, 0);
                for (int i = 0; i < index.Length; i++) {
                    Type DataType = index[i].DataType;
                    DataRelation relation = index[i].FindParentRelation();
                    if (ChildRelationFollowable(relation)) {
                        string ParentTypedRowName = RowClassName(relation.ParentTable);
                        string argumentName = FixIdName("parent" + ParentTypedRowName + "By" + relation.RelationName);
                        addByColName.Parameters.Add(ParameterDecl(ParentTypedRowName, argumentName));
                    }
                    else {
                        addByColName.Parameters.Add(ParameterDecl(GetTypeName(DataType), RowColumnPropertyName(index[i])));
                    }
                }
                addByColName.Statements.Add(VariableDecl(stRowConcreateClassName, "row" + stRowClassName, Cast(stRowConcreateClassName, MethodCall(This(), "NewRow"))));
                CodeExpression varRow = Variable("row" + stRowClassName);

                CodeAssignStatement assignStmt = new CodeAssignStatement(); {
                    assignStmt.Left = Property(varRow, "ItemArray");
                    CodeArrayCreateExpression newArray = new CodeArrayCreateExpression();
                    newArray.CreateType = Type(typeof(object));
                    
                    index = new DataColumn[table.Columns.Count];
                    table.Columns.CopyTo(index, 0);
                    
                    for (int i = 0; i < index.Length; i++) {
                        if (index[i].AutoIncrement) {
                            newArray.Initializers.Add(Primitive(null));
                        }else {
                            DataRelation relation = index[i].FindParentRelation();
                            if (ChildRelationFollowable(relation)) {
                                string ParentTypedRowName = RowClassName(relation.ParentTable);
                                string argumentName = FixIdName("parent" + ParentTypedRowName + "By" + relation.RelationName);
                                newArray.Initializers.Add(Indexer(Argument(argumentName), Primitive(relation.ParentColumnsReference[0].Ordinal)));
                            }
                            else {
                                newArray.Initializers.Add(Argument(RowColumnPropertyName(index[i])));
                            }
                        }
                    }

                    assignStmt.Right = newArray;
                }
                addByColName.Statements.Add(assignStmt);

                addByColName.Statements.Add(MethodCall(Property(This(), "Rows"), "Add", varRow));
                addByColName.Statements.Add(Return(varRow));
            }
            dataTableClass.Members.Add(addByColName);

            for (int j = 0; j < table.Constraints.Count; j++) {
                if (!(table.Constraints[j] is UniqueConstraint)) {
                    continue;
                }

                if (!(((UniqueConstraint)(table.Constraints[j])).IsPrimaryKey)) {
                    continue;
                }

                DataColumn[] index = ((UniqueConstraint)table.Constraints[j]).ColumnsReference;
                string FindByName = "FindBy";
                bool AllHidden = true;
                for (int i = 0; i < index.Length; i++) {                    
                    FindByName += RowColumnPropertyName(index[i]);
                    if(index[i].ColumnMapping != MappingType.Hidden) {
                        AllHidden = false;
                    }
                }

                if(AllHidden) {
                    continue; // We are not generating FindBy* methods for hidden columns
                }

                //\\ public <RowClassName> FindBy<ColName>[...](<ColType> <ColName>[, ...]) {
                //\\    return (<RowClassName>)(this.Rows.Find(new Object[] {<ColName>[, ...]}));
                //\\ }
                CodeMemberMethod findBy = MethodDecl(stRowClassName, FixIdName(FindByName), MemberAttributes.Public | MemberAttributes.Final); {
                    for (int i = 0; i < index.Length; i++) {
                        findBy.Parameters.Add(ParameterDecl(GetTypeName(index[i].DataType), RowColumnPropertyName(index[i])));
                    }

                    CodeArrayCreateExpression arrayCreate = new CodeArrayCreateExpression(typeof(object), index.Length);
                    for (int i = 0; i < index.Length; i++) {
                        arrayCreate.Initializers.Add(Argument(RowColumnPropertyName(index[i])));
                    }
                    findBy.Statements.Add(Return(Cast(stRowClassName, MethodCall(Property(This(), "Rows"), "Find", arrayCreate))));
                }
                dataTableClass.Members.Add(findBy);
            }

            //\\ public System.Collections.IEnumerator GetEnumerator() {
            //\\     return this.GetEnumerator();
            //\\ }
            CodeMemberMethod getEnumerator = MethodDecl(typeof(System.Collections.IEnumerator), "GetEnumerator", MemberAttributes.Public | MemberAttributes.Final); {
                getEnumerator.ImplementationTypes.Add(Type("System.Collections.IEnumerable"));
                getEnumerator.Statements.Add(Return(MethodCall(Property(This(), "Rows"), "GetEnumerator")));
            }
            dataTableClass.Members.Add(getEnumerator);

            //\\ public override DataTable Clone() {
            //\\     <TableClassName> cln = (<TableClassName)base.Clone();
            //\\     cln.InitVars();
            //\\     return cln;
            //\\ }
            CodeMemberMethod clone = MethodDecl(typeof(DataTable), "Clone", MemberAttributes.Public | MemberAttributes.Override); {
                clone.Statements.Add(VariableDecl(stTblClassName, "cln", Cast(stTblClassName, MethodCall(Base(), "Clone", new CodeExpression[] {}))));
                clone.Statements.Add(MethodCall(Variable("cln"), "InitVars", new CodeExpression [] {}));
                clone.Statements.Add(Return(Variable("cln")));
            }
            dataTableClass.Members.Add(clone);

            //\\ protected override DataTable CreateInstance() {
            //\\     return new <TableClassName>()
            //\\ }
            CodeMemberMethod createInstance = MethodDecl(typeof(DataTable), "CreateInstance", MemberAttributes.Family | MemberAttributes.Override); {
	         createInstance.Statements.Add(Return(New(stTblClassName, new CodeExpression[] {}))); 
	     }
            dataTableClass.Members.Add(createInstance);

            //\\ private void InitClass() ...
            CodeMemberMethod tableInitClass = MethodDecl(typeof(void), "InitClass", MemberAttributes.Private); {

            //\\ public void InitVars() ...
            CodeMemberMethod tableInitVars = MethodDecl(typeof(void), "InitVars", MemberAttributes.Assembly | MemberAttributes.Final); {

                for (int i = 0; i < table.Columns.Count; i++) {
                    DataColumn column = table.Columns[i];
                    string ColumnName = TableColumnFieldName(column);
                    //\\ this.column<ColumnName>
                    CodeExpression codeField = Field(This(), ColumnName);

                    //\\ this.column<ColumnName> = new DataColumn("<ColumnName>", typeof(<ColumnType>), "", MappingType.Hidden);
                    tableInitClass.Statements.Add(Assign(codeField, 
                        New(typeof(DataColumn), 
                            new CodeExpression[] {
                                Str(column.ColumnName),
                                TypeOf(GetTypeName(column.DataType)),
                                Primitive(null),
                                Field(TypeExpr(typeof(MappingType)), 
                                    (column.ColumnMapping == MappingType.SimpleContent) ? "SimpleContent"      :
                                    (column.ColumnMapping == MappingType.Attribute    ) ? "Attribute" :
                                    (column.ColumnMapping == MappingType.Hidden       ) ? "Hidden"    :
                                    /*defult*/                                            "Element" 
                                )
                            }
                        )
                    ));
                    //\\ this.Columns.Add(this.column<ColumnName>);
                    tableInitClass.Statements.Add(MethodCall(Property(This(), "Columns"), "Add", Field(This(), ColumnName)));
                }

                for (int i = 0; i < table.Constraints.Count; i++) {
                    if (!(table.Constraints[i] is UniqueConstraint)) {
                        continue;
                    }
                    //\\ this.Constraints.Add = new UniqueConstraint(<constraintName>, new DataColumn[] {this.column<ColumnName> [, ...]});
                    UniqueConstraint uc = (UniqueConstraint)(table.Constraints[i]);
                    DataColumn[] columns = uc.ColumnsReference;
                    CodeExpression[] createArgs = new CodeExpression[columns.Length]; {
                        for (int j = 0; j < columns.Length; j++) {
                            createArgs[j] = Field(This(), TableColumnFieldName(columns[j]));
                        }
                    }
                    tableInitClass.Statements.Add(MethodCall(Property(This(), "Constraints"), "Add",
                        New(typeof(UniqueConstraint), 
                        new CodeExpression[] {
                                                Str(uc.ConstraintName),
                                                new CodeArrayCreateExpression(typeof(DataColumn), createArgs),
                                                Primitive(uc.IsPrimaryKey)
                                             }
                        )
                    ));
                }

                for (int i = 0; i < table.Columns.Count; i++) {
                    DataColumn column = table.Columns[i];
                    string ColumnName = TableColumnFieldName(column);
                    //\\ this.column<ColumnName>
                    CodeExpression codeField = Field(This(), ColumnName);

                    //\\ this.column<ColumnName> = this.Columns["<ColumnName>"];
                    tableInitVars.Statements.Add(Assign(codeField, Indexer(Property(This(),"Columns"),Str(column.ColumnName))));

                    if (column.AutoIncrement) {
                        //\\ this.column<ColumnName>.AutoIncrement = true;
                        tableInitClass.Statements.Add(Assign(Property(codeField, "AutoIncrement"), Primitive(true)));
                    }
                    if (column.AutoIncrementSeed != 0) {
                        //\\ this.column<ColumnName>.AutoIncrementSeed = <column.AutoIncrementSeed>;
                        tableInitClass.Statements.Add(Assign(Property(codeField, "AutoIncrementSeed"), Primitive(column.AutoIncrementSeed)));
                    }
                    if (column.AutoIncrementStep != 1) {
                        //\\ this.column<ColumnName>.AutoIncrementStep = <column.AutoIncrementStep>;
                        tableInitClass.Statements.Add(Assign(Property(codeField, "AutoIncrementStep"), Primitive(column.AutoIncrementStep)));
                    }
                    if (!column.AllowDBNull) {
                        //\\ this.column<ColumnName>.AllowDBNull = false;
                        tableInitClass.Statements.Add(Assign(Property(codeField, "AllowDBNull"), Primitive(false)));
                    }
                    if (column.ReadOnly) {
                        //\\ this.column<ColumnName>.ReadOnly = true;
                        tableInitClass.Statements.Add(Assign(Property(codeField, "ReadOnly"), Primitive(true)));
                    }
                    if (column.Unique) {
                        //\\ this.column<ColumnName>.Unique = true;
                        tableInitClass.Statements.Add(Assign(Property(codeField, "Unique"), Primitive(true)));
                    }

                    if (!Common.ADP.IsEmpty(column.Prefix)) {
                        //\\ this.column<ColumnName>.Prefix = "<column.Prefix>";
                        tableInitClass.Statements.Add(Assign(Property(codeField, "Prefix"), Str(column.Prefix)));
                    }
                    if (column._columnUri != null) {
                        //\\ this.column<ColumnName>.Namespace = "<column.Namespace>";
                        tableInitClass.Statements.Add(Assign(Property(codeField, "Namespace"), Str(column.Namespace)));
                    }
                    if (column.Caption != column.ColumnName) {
                        //\\ this.column<ColumnName>.Caption = "<column.Caption>";
                        tableInitClass.Statements.Add(Assign(Property(codeField, "Caption"), Str(column.Caption)));
                    }
                    if (column.DefaultValue != DBNull.Value) {
                        //\\ this.column<ColumnName>.DefaultValue = "<column.DefaultValue>";
                        tableInitClass.Statements.Add(Assign(Property(codeField, "DefaultValue"), Primitive(column.DefaultValue)));
                    }
                    if (column.MaxLength != -1) {
                        //\\ this.column<ColumnName>.MaxLength = "<column.MaxLength>";
                        tableInitClass.Statements.Add(Assign(Property(codeField, "MaxLength"), Primitive(column.MaxLength)));
                    }
                }

                if (table.ShouldSerializeCaseSensitive()) {
                    //\\ this.CaseSensitive = <CaseSensitive>;
                    tableInitClass.Statements.Add(Assign(Property(This(), "CaseSensitive"), Primitive(table.CaseSensitive)));
                }
                if (table.ShouldSerializeLocale()) {
                    //\\ this.Locale = new System.Globalization.CultureInfo("<Locale>");
                    tableInitClass.Statements.Add(Assign(Property(This(), "Locale"), New(typeof(System.Globalization.CultureInfo),new CodeExpression[] {Str(table.Locale.ToString())})));
                }
                if (!Common.ADP.IsEmpty(table.Prefix)) {
                    //\\ this.Prefix = "<Prefix>";
                    tableInitClass.Statements.Add(Assign(Property(This(), "Prefix"), Str(table.Prefix)));
                }
                if (table.tableNamespace != null) {
                    //\\ this.Namespace = <Namespace>;
                    tableInitClass.Statements.Add(Assign(Property(This(), "Namespace"), Str(table.Namespace)));
                }

                if (table.MinimumCapacity != 50) {
                    //\\ this.MinimumCapacity = <MinimumCapacity>;
                    tableInitClass.Statements.Add(Assign(Property(This(), "MinimumCapacity"), Primitive(table.MinimumCapacity)));
                }
                if (table.displayExpression != null) {
                    //\\ this.DisplayExpression = "<DisplayExpression>";
                    tableInitClass.Statements.Add(Assign(Property(This(), "DisplayExpression"), Str(table.DisplayExpressionInternal)));
                }
            }
            dataTableClass.Members.Add(tableInitVars);
            }
            dataTableClass.Members.Add(tableInitClass);

            //\\ public <RowClassName> New<RowClassName>() {
            //\\     return (<RowClassName>) NewRow();
            //\\ }
            CodeMemberMethod newTableRow = MethodDecl(stRowConcreateClassName, "New" + stRowClassName, MemberAttributes.Public | MemberAttributes.Final); {
                newTableRow.Statements.Add(Return(Cast(stRowConcreateClassName, MethodCall(This(), "NewRow"))));
            }
            dataTableClass.Members.Add(newTableRow);

            //\\ protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
            //\\     return new<RowClassName>(builder);
            //\\ }
            CodeMemberMethod newRowFromBuilder = MethodDecl(typeof(DataRow), "NewRowFromBuilder", MemberAttributes.Family | MemberAttributes.Override); {
                newRowFromBuilder.Parameters.Add(ParameterDecl(typeof(DataRowBuilder), "builder"));
                newRowFromBuilder.Statements.Add(Return(New(stRowConcreateClassName, new CodeExpression[] {Argument("builder")})));
            }
            dataTableClass.Members.Add(newRowFromBuilder);

            //\\ protected override System.Type GetRowType() {
            //\\     return typeof(<RowConcreateClassName>);
            //\\ }        
            CodeMemberMethod getRowType = MethodDecl(typeof(System.Type), "GetRowType", MemberAttributes.Family | MemberAttributes.Override); {
                getRowType.Statements.Add(Return(TypeOf(stRowConcreateClassName)));
            }
            dataTableClass.Members.Add(getRowType);

            dataTableClass.Members.Add(CreateOnRowEventMethod("Changed" , stRowClassName));
            dataTableClass.Members.Add(CreateOnRowEventMethod("Changing", stRowClassName));
            dataTableClass.Members.Add(CreateOnRowEventMethod("Deleted" , stRowClassName));
            dataTableClass.Members.Add(CreateOnRowEventMethod("Deleting", stRowClassName));

            //\\ public void Remove<RowClassName>(<RowClassName> row) {
            //\\     this.Rows.Remove(row);
            //\\ }
            CodeMemberMethod removeMethod = MethodDecl(typeof(void), "Remove" + stRowClassName, MemberAttributes.Public | MemberAttributes.Final); {
                removeMethod.Parameters.Add(ParameterDecl(stRowConcreateClassName, "row"));
                removeMethod.Statements.Add(MethodCall(Property(This(), "Rows"), "Remove", Argument("row")));
            }
            dataTableClass.Members.Add(removeMethod);

            return dataTableClass;
        }// CreateTypedTable
 private CodeTypeDeclaration CreateTypedTable(DataTable table)
 {
     string str = this.RowClassName(table);
     string name = this.TableClassName(table);
     string str2 = this.RowConcreteClassName(table);
     CodeTypeDeclaration declaration = new CodeTypeDeclaration(name);
     declaration.BaseTypes.Add(typeof(DataTable));
     declaration.BaseTypes.Add(typeof(IEnumerable));
     declaration.CustomAttributes.Add(AttributeDecl("System.Serializable"));
     declaration.CustomAttributes.Add(AttributeDecl("System.Diagnostics.DebuggerStepThrough"));
     for (int i = 0; i < table.Columns.Count; i++)
     {
         declaration.Members.Add(FieldDecl(typeof(DataColumn), this.TableColumnFieldName(table.Columns[i])));
     }
     declaration.Members.Add(EventDecl(str + "ChangeEventHandler", str + "Changed"));
     declaration.Members.Add(EventDecl(str + "ChangeEventHandler", str + "Changing"));
     declaration.Members.Add(EventDecl(str + "ChangeEventHandler", str + "Deleted"));
     declaration.Members.Add(EventDecl(str + "ChangeEventHandler", str + "Deleting"));
     CodeConstructor constructor = new CodeConstructor {
         Attributes = MemberAttributes.Assembly | MemberAttributes.Final
     };
     constructor.BaseConstructorArgs.Add(Str(table.TableName));
     constructor.Statements.Add(MethodCall(This(), "InitClass"));
     declaration.Members.Add(constructor);
     constructor = new CodeConstructor {
         Attributes = MemberAttributes.Family
     };
     constructor.Parameters.Add(ParameterDecl(typeof(SerializationInfo), "info"));
     constructor.Parameters.Add(ParameterDecl(typeof(StreamingContext), "context"));
     constructor.BaseConstructorArgs.AddRange(new CodeExpression[] { Argument("info"), Argument("context") });
     constructor.Statements.Add(MethodCall(This(), "InitVars"));
     declaration.Members.Add(constructor);
     constructor = new CodeConstructor {
         Attributes = MemberAttributes.Assembly | MemberAttributes.Final
     };
     constructor.Parameters.Add(ParameterDecl(typeof(DataTable), "table"));
     constructor.BaseConstructorArgs.Add(Property(Argument("table"), "TableName"));
     constructor.Statements.Add(If(IdNotEQ(Property(Argument("table"), "CaseSensitive"), Property(Property(Argument("table"), "DataSet"), "CaseSensitive")), Assign(Property(This(), "CaseSensitive"), Property(Argument("table"), "CaseSensitive"))));
     constructor.Statements.Add(If(IdNotEQ(MethodCall(Property(Argument("table"), "Locale"), "ToString"), MethodCall(Property(Property(Argument("table"), "DataSet"), "Locale"), "ToString")), Assign(Property(This(), "Locale"), Property(Argument("table"), "Locale"))));
     constructor.Statements.Add(If(IdNotEQ(Property(Argument("table"), "Namespace"), Property(Property(Argument("table"), "DataSet"), "Namespace")), Assign(Property(This(), "Namespace"), Property(Argument("table"), "Namespace"))));
     constructor.Statements.Add(Assign(Property(This(), "Prefix"), Property(Argument("table"), "Prefix")));
     constructor.Statements.Add(Assign(Property(This(), "MinimumCapacity"), Property(Argument("table"), "MinimumCapacity")));
     constructor.Statements.Add(Assign(Property(This(), "DisplayExpression"), Property(Argument("table"), "DisplayExpression")));
     declaration.Members.Add(constructor);
     CodeMemberProperty property2 = PropertyDecl(typeof(int), "Count", MemberAttributes.Public | MemberAttributes.Final);
     property2.CustomAttributes.Add(AttributeDecl("System.ComponentModel.Browsable", Primitive(false)));
     property2.GetStatements.Add(Return(Property(Property(This(), "Rows"), "Count")));
     declaration.Members.Add(property2);
     for (int j = 0; j < table.Columns.Count; j++)
     {
         DataColumn column3 = table.Columns[j];
         CodeMemberProperty property3 = PropertyDecl(typeof(DataColumn), this.TableColumnPropertyName(column3), MemberAttributes.Assembly | MemberAttributes.Final);
         property3.GetStatements.Add(Return(Field(This(), this.TableColumnFieldName(column3))));
         declaration.Members.Add(property3);
     }
     CodeMemberProperty property = PropertyDecl(str2, "Item", MemberAttributes.Public | MemberAttributes.Final);
     property.Parameters.Add(ParameterDecl(typeof(int), "index"));
     property.GetStatements.Add(Return(Cast(str2, Indexer(Property(This(), "Rows"), Argument("index")))));
     declaration.Members.Add(property);
     CodeMemberMethod method8 = MethodDecl(typeof(void), "Add" + str, MemberAttributes.Public | MemberAttributes.Final);
     method8.Parameters.Add(ParameterDecl(str2, "row"));
     method8.Statements.Add(MethodCall(Property(This(), "Rows"), "Add", Argument("row")));
     declaration.Members.Add(method8);
     ArrayList list = new ArrayList();
     for (int k = 0; k < table.Columns.Count; k++)
     {
         if (!table.Columns[k].AutoIncrement)
         {
             list.Add(table.Columns[k]);
         }
     }
     CodeMemberMethod method2 = MethodDecl(str2, "Add" + str, MemberAttributes.Public | MemberAttributes.Final);
     DataColumn[] array = new DataColumn[list.Count];
     list.CopyTo(array, 0);
     for (int m = 0; m < array.Length; m++)
     {
         System.Type dataType = array[m].DataType;
         DataRelation relation2 = array[m].FindParentRelation();
         if (this.ChildRelationFollowable(relation2))
         {
             string type = this.RowClassName(relation2.ParentTable);
             string str10 = this.FixIdName("parent" + type + "By" + relation2.RelationName);
             method2.Parameters.Add(ParameterDecl(type, str10));
         }
         else
         {
             method2.Parameters.Add(ParameterDecl(this.GetTypeName(dataType), this.RowColumnPropertyName(array[m])));
         }
     }
     method2.Statements.Add(VariableDecl(str2, "row" + str, Cast(str2, MethodCall(This(), "NewRow"))));
     CodeExpression exp = Variable("row" + str);
     CodeAssignStatement statement = new CodeAssignStatement {
         Left = Property(exp, "ItemArray")
     };
     CodeArrayCreateExpression expression2 = new CodeArrayCreateExpression {
         CreateType = Type(typeof(object))
     };
     array = new DataColumn[table.Columns.Count];
     table.Columns.CopyTo(array, 0);
     for (int n = 0; n < array.Length; n++)
     {
         if (array[n].AutoIncrement)
         {
             expression2.Initializers.Add(Primitive(null));
         }
         else
         {
             DataRelation relation = array[n].FindParentRelation();
             if (this.ChildRelationFollowable(relation))
             {
                 string argument = this.FixIdName("parent" + this.RowClassName(relation.ParentTable) + "By" + relation.RelationName);
                 expression2.Initializers.Add(Indexer(Argument(argument), Primitive(relation.ParentColumnsReference[0].Ordinal)));
             }
             else
             {
                 expression2.Initializers.Add(Argument(this.RowColumnPropertyName(array[n])));
             }
         }
     }
     statement.Right = expression2;
     method2.Statements.Add(statement);
     method2.Statements.Add(MethodCall(Property(This(), "Rows"), "Add", exp));
     method2.Statements.Add(Return(exp));
     declaration.Members.Add(method2);
     for (int num = 0; num < table.Constraints.Count; num++)
     {
         if ((table.Constraints[num] is UniqueConstraint) && ((UniqueConstraint) table.Constraints[num]).IsPrimaryKey)
         {
             DataColumn[] columnsReference = ((UniqueConstraint) table.Constraints[num]).ColumnsReference;
             string inVarName = "FindBy";
             bool flag = true;
             for (int num7 = 0; num7 < columnsReference.Length; num7++)
             {
                 inVarName = inVarName + this.RowColumnPropertyName(columnsReference[num7]);
                 if (columnsReference[num7].ColumnMapping != MappingType.Hidden)
                 {
                     flag = false;
                 }
             }
             if (!flag)
             {
                 CodeMemberMethod method7 = MethodDecl(str, this.FixIdName(inVarName), MemberAttributes.Public | MemberAttributes.Final);
                 for (int num6 = 0; num6 < columnsReference.Length; num6++)
                 {
                     method7.Parameters.Add(ParameterDecl(this.GetTypeName(columnsReference[num6].DataType), this.RowColumnPropertyName(columnsReference[num6])));
                 }
                 CodeArrayCreateExpression par = new CodeArrayCreateExpression(typeof(object), columnsReference.Length);
                 for (int num11 = 0; num11 < columnsReference.Length; num11++)
                 {
                     par.Initializers.Add(Argument(this.RowColumnPropertyName(columnsReference[num11])));
                 }
                 method7.Statements.Add(Return(Cast(str, MethodCall(Property(This(), "Rows"), "Find", par))));
                 declaration.Members.Add(method7);
             }
         }
     }
     CodeMemberMethod method6 = MethodDecl(typeof(IEnumerator), "GetEnumerator", MemberAttributes.Public | MemberAttributes.Final);
     method6.ImplementationTypes.Add(Type("System.Collections.IEnumerable"));
     method6.Statements.Add(Return(MethodCall(Property(This(), "Rows"), "GetEnumerator")));
     declaration.Members.Add(method6);
     CodeMemberMethod method3 = MethodDecl(typeof(DataTable), "Clone", MemberAttributes.Public | MemberAttributes.Override);
     method3.Statements.Add(VariableDecl(name, "cln", Cast(name, MethodCall(Base(), "Clone", new CodeExpression[0]))));
     method3.Statements.Add(MethodCall(Variable("cln"), "InitVars", new CodeExpression[0]));
     method3.Statements.Add(Return(Variable("cln")));
     declaration.Members.Add(method3);
     CodeMemberMethod method12 = MethodDecl(typeof(DataTable), "CreateInstance", MemberAttributes.Family | MemberAttributes.Override);
     method12.Statements.Add(Return(New(name, new CodeExpression[0])));
     declaration.Members.Add(method12);
     CodeMemberMethod method = MethodDecl(typeof(void), "InitClass", MemberAttributes.Private);
     CodeMemberMethod method11 = MethodDecl(typeof(void), "InitVars", MemberAttributes.Assembly | MemberAttributes.Final);
     for (int num10 = 0; num10 < table.Columns.Count; num10++)
     {
         DataColumn column2 = table.Columns[num10];
         string field = this.TableColumnFieldName(column2);
         CodeExpression left = Field(This(), field);
         method.Statements.Add(Assign(left, New(typeof(DataColumn), new CodeExpression[] { Str(column2.ColumnName), TypeOf(this.GetTypeName(column2.DataType)), Primitive(null), Field(TypeExpr(typeof(MappingType)), (column2.ColumnMapping == MappingType.SimpleContent) ? "SimpleContent" : ((column2.ColumnMapping == MappingType.Attribute) ? "Attribute" : ((column2.ColumnMapping == MappingType.Hidden) ? "Hidden" : "Element"))) })));
         method.Statements.Add(MethodCall(Property(This(), "Columns"), "Add", Field(This(), field)));
     }
     for (int num5 = 0; num5 < table.Constraints.Count; num5++)
     {
         if (table.Constraints[num5] is UniqueConstraint)
         {
             UniqueConstraint constraint = (UniqueConstraint) table.Constraints[num5];
             DataColumn[] columnArray3 = constraint.ColumnsReference;
             CodeExpression[] initializers = new CodeExpression[columnArray3.Length];
             for (int num4 = 0; num4 < columnArray3.Length; num4++)
             {
                 initializers[num4] = Field(This(), this.TableColumnFieldName(columnArray3[num4]));
             }
             method.Statements.Add(MethodCall(Property(This(), "Constraints"), "Add", New(typeof(UniqueConstraint), new CodeExpression[] { Str(constraint.ConstraintName), new CodeArrayCreateExpression(typeof(DataColumn), initializers), Primitive(constraint.IsPrimaryKey) })));
         }
     }
     for (int num9 = 0; num9 < table.Columns.Count; num9++)
     {
         DataColumn column = table.Columns[num9];
         string str7 = this.TableColumnFieldName(column);
         CodeExpression expression = Field(This(), str7);
         method11.Statements.Add(Assign(expression, Indexer(Property(This(), "Columns"), Str(column.ColumnName))));
         if (column.AutoIncrement)
         {
             method.Statements.Add(Assign(Property(expression, "AutoIncrement"), Primitive(true)));
         }
         if (column.AutoIncrementSeed != 0L)
         {
             method.Statements.Add(Assign(Property(expression, "AutoIncrementSeed"), Primitive(column.AutoIncrementSeed)));
         }
         if (column.AutoIncrementStep != 1L)
         {
             method.Statements.Add(Assign(Property(expression, "AutoIncrementStep"), Primitive(column.AutoIncrementStep)));
         }
         if (!column.AllowDBNull)
         {
             method.Statements.Add(Assign(Property(expression, "AllowDBNull"), Primitive(false)));
         }
         if (column.ReadOnly)
         {
             method.Statements.Add(Assign(Property(expression, "ReadOnly"), Primitive(true)));
         }
         if (column.Unique)
         {
             method.Statements.Add(Assign(Property(expression, "Unique"), Primitive(true)));
         }
         if (!ADP.IsEmpty(column.Prefix))
         {
             method.Statements.Add(Assign(Property(expression, "Prefix"), Str(column.Prefix)));
         }
         if (column._columnUri != null)
         {
             method.Statements.Add(Assign(Property(expression, "Namespace"), Str(column.Namespace)));
         }
         if (column.Caption != column.ColumnName)
         {
             method.Statements.Add(Assign(Property(expression, "Caption"), Str(column.Caption)));
         }
         if (column.DefaultValue != DBNull.Value)
         {
             method.Statements.Add(Assign(Property(expression, "DefaultValue"), Primitive(column.DefaultValue)));
         }
         if (column.MaxLength != -1)
         {
             method.Statements.Add(Assign(Property(expression, "MaxLength"), Primitive(column.MaxLength)));
         }
     }
     if (table.ShouldSerializeCaseSensitive())
     {
         method.Statements.Add(Assign(Property(This(), "CaseSensitive"), Primitive(table.CaseSensitive)));
     }
     if (table.ShouldSerializeLocale())
     {
         method.Statements.Add(Assign(Property(This(), "Locale"), New(typeof(CultureInfo), new CodeExpression[] { Str(table.Locale.ToString()) })));
     }
     if (!ADP.IsEmpty(table.Prefix))
     {
         method.Statements.Add(Assign(Property(This(), "Prefix"), Str(table.Prefix)));
     }
     if (table.tableNamespace != null)
     {
         method.Statements.Add(Assign(Property(This(), "Namespace"), Str(table.Namespace)));
     }
     if (table.MinimumCapacity != 50)
     {
         method.Statements.Add(Assign(Property(This(), "MinimumCapacity"), Primitive(table.MinimumCapacity)));
     }
     if (table.displayExpression != null)
     {
         method.Statements.Add(Assign(Property(This(), "DisplayExpression"), Str(table.DisplayExpressionInternal)));
     }
     declaration.Members.Add(method11);
     declaration.Members.Add(method);
     CodeMemberMethod method10 = MethodDecl(str2, "New" + str, MemberAttributes.Public | MemberAttributes.Final);
     method10.Statements.Add(Return(Cast(str2, MethodCall(This(), "NewRow"))));
     declaration.Members.Add(method10);
     CodeMemberMethod method5 = MethodDecl(typeof(DataRow), "NewRowFromBuilder", MemberAttributes.Family | MemberAttributes.Override);
     method5.Parameters.Add(ParameterDecl(typeof(DataRowBuilder), "builder"));
     method5.Statements.Add(Return(New(str2, new CodeExpression[] { Argument("builder") })));
     declaration.Members.Add(method5);
     CodeMemberMethod method9 = MethodDecl(typeof(System.Type), "GetRowType", MemberAttributes.Family | MemberAttributes.Override);
     method9.Statements.Add(Return(TypeOf(str2)));
     declaration.Members.Add(method9);
     declaration.Members.Add(CreateOnRowEventMethod("Changed", str));
     declaration.Members.Add(CreateOnRowEventMethod("Changing", str));
     declaration.Members.Add(CreateOnRowEventMethod("Deleted", str));
     declaration.Members.Add(CreateOnRowEventMethod("Deleting", str));
     CodeMemberMethod method4 = MethodDecl(typeof(void), "Remove" + str, MemberAttributes.Public | MemberAttributes.Final);
     method4.Parameters.Add(ParameterDecl(str2, "row"));
     method4.Statements.Add(MethodCall(Property(This(), "Rows"), "Remove", Argument("row")));
     declaration.Members.Add(method4);
     return declaration;
 }