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; }
}// 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
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; }
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; }