private void AddTransactionMembers(CodeTypeDeclaration dataComponentClass)
{
Type transactionType = this.designTable.PropertyCache.TransactionType;
if (transactionType != null)
{
CodeTypeReference type = CodeGenHelper.GlobalType(transactionType);
dataComponentClass.Members.Add(CodeGenHelper.FieldDecl(type, DataComponentNameHandler.TransactionVariableName));
CodeMemberProperty property = CodeGenHelper.PropertyDecl(type, DataComponentNameHandler.TransactionPropertyName, MemberAttributes.Assembly | MemberAttributes.Final);
property.GetStatements.Add(CodeGenHelper.Return(CodeGenHelper.Field(CodeGenHelper.This(), DataComponentNameHandler.TransactionVariableName)));
property.SetStatements.Add(CodeGenHelper.Assign(CodeGenHelper.Field(CodeGenHelper.This(), DataComponentNameHandler.TransactionVariableName), CodeGenHelper.Argument("value")));
CodeStatement initStmt = CodeGenHelper.VariableDecl(CodeGenHelper.Type(typeof(int)), "i", CodeGenHelper.Primitive(0));
CodeExpression testExpression = CodeGenHelper.Less(CodeGenHelper.Variable("i"), CodeGenHelper.Property(CodeGenHelper.Property(CodeGenHelper.This(), DataComponentNameHandler.SelectCmdCollectionPropertyName), "Length"));
CodeStatement incrementStmt = CodeGenHelper.Assign(CodeGenHelper.Variable("i"), CodeGenHelper.BinOperator(CodeGenHelper.Variable("i"), CodeBinaryOperatorType.Add, CodeGenHelper.Primitive(1)));
CodeExpression transaction = CodeGenHelper.Property(CodeGenHelper.Indexer(CodeGenHelper.Property(CodeGenHelper.This(), DataComponentNameHandler.SelectCmdCollectionPropertyName), CodeGenHelper.Variable("i")), "Transaction");
CodeExpression oldTransaction = CodeGenHelper.Variable("oldTransaction");
CodeExpression newTransaction = CodeGenHelper.Field(CodeGenHelper.This(), DataComponentNameHandler.TransactionVariableName);
CodeStatement statement3 = this.GenerateSetTransactionStmt(transaction, oldTransaction, newTransaction);
property.SetStatements.Add(CodeGenHelper.ForLoop(initStmt, testExpression, incrementStmt, new CodeStatement[] { statement3 }));
CodeExpression exp = CodeGenHelper.Property(CodeGenHelper.This(), DataComponentNameHandler.AdapterPropertyName);
CodeExpression expression6 = CodeGenHelper.Property(exp, "DeleteCommand");
transaction = CodeGenHelper.Property(expression6, "Transaction");
property.SetStatements.Add(CodeGenHelper.If(CodeGenHelper.And(CodeGenHelper.IdNotEQ(exp, CodeGenHelper.Primitive(null)), CodeGenHelper.IdNotEQ(expression6, CodeGenHelper.Primitive(null))), this.GenerateSetTransactionStmt(transaction, oldTransaction, newTransaction)));
expression6 = CodeGenHelper.Property(exp, "InsertCommand");
transaction = CodeGenHelper.Property(expression6, "Transaction");
property.SetStatements.Add(CodeGenHelper.If(CodeGenHelper.And(CodeGenHelper.IdNotEQ(exp, CodeGenHelper.Primitive(null)), CodeGenHelper.IdNotEQ(expression6, CodeGenHelper.Primitive(null))), this.GenerateSetTransactionStmt(transaction, oldTransaction, newTransaction)));
expression6 = CodeGenHelper.Property(exp, "UpdateCommand");
transaction = CodeGenHelper.Property(expression6, "Transaction");
property.SetStatements.Add(CodeGenHelper.If(CodeGenHelper.And(CodeGenHelper.IdNotEQ(exp, CodeGenHelper.Primitive(null)), CodeGenHelper.IdNotEQ(expression6, CodeGenHelper.Primitive(null))), this.GenerateSetTransactionStmt(transaction, oldTransaction, newTransaction)));
dataComponentClass.Members.Add(property);
}
}
private void AddParametersToMethod(CodeMemberMethod dbMethod)
{
CodeParameterDeclarationExpression expression = null;
if (base.activeCommand.Parameters != null)
{
DesignConnection connection = (DesignConnection)base.methodSource.Connection;
if (connection == null)
{
throw new InternalException("Connection for query '" + base.methodSource.Name + "' is null.");
}
string parameterPrefix = connection.ParameterPrefix;
foreach (DesignParameter parameter in base.activeCommand.Parameters)
{
if (parameter.Direction != ParameterDirection.ReturnValue)
{
Type parameterUrtType = base.GetParameterUrtType(parameter);
string name = base.nameHandler.AddParameterNameToList(parameter.ParameterName, parameterPrefix);
CodeTypeReference type = null;
if (parameter.AllowDbNull && parameterUrtType.IsValueType)
{
type = CodeGenHelper.NullableType(parameterUrtType);
}
else
{
type = CodeGenHelper.Type(parameterUrtType);
}
expression = CodeGenHelper.ParameterDecl(type, name);
expression.Direction = CodeGenHelper.ParameterDirectionToFieldDirection(parameter.Direction);
dbMethod.Parameters.Add(expression);
}
}
}
}
private CodeMemberMethod NewTypedRowMethod()
{
CodeMemberMethod method = CodeGenHelper.MethodDecl(CodeGenHelper.Type(this.rowConcreteClassName), NameHandler.FixIdName("New" + this.rowClassName), MemberAttributes.Public | MemberAttributes.Final);
method.Statements.Add(CodeGenHelper.Return(CodeGenHelper.Cast(CodeGenHelper.Type(this.rowConcreteClassName), CodeGenHelper.MethodCall(CodeGenHelper.This(), "NewRow"))));
return(method);
}
private CodeMemberMethod GenerateInternal()
{
base.returnType = typeof(int);
CodeMemberMethod dbMethod = null;
if (base.getMethod)
{
dbMethod = CodeGenHelper.MethodDecl(CodeGenHelper.Type(base.ContainerParameterTypeName), base.MethodName, base.methodAttributes);
}
else
{
dbMethod = CodeGenHelper.MethodDecl(CodeGenHelper.Type(base.returnType), base.MethodName, base.methodAttributes);
}
dbMethod.CustomAttributes.Add(CodeGenHelper.AttributeDecl(typeof(HelpKeywordAttribute).FullName, CodeGenHelper.Str("vs.data.TableAdapter")));
this.AddParametersToMethod(dbMethod);
if (base.declarationOnly)
{
base.AddThrowsClauseIfNeeded(dbMethod);
return(dbMethod);
}
this.AddCustomAttributesToMethod(dbMethod);
if (this.AddStatementsToMethod(dbMethod))
{
return(dbMethod);
}
return(null);
}
private CodeMemberMethod GetTypedTableSchema()
{
CodeMemberMethod method = CodeGenHelper.MethodDecl(CodeGenHelper.GlobalType(typeof(XmlSchemaComplexType)), "GetTypedTableSchema", MemberAttributes.Public | MemberAttributes.Static);
method.Parameters.Add(CodeGenHelper.ParameterDecl(CodeGenHelper.GlobalType(typeof(XmlSchemaSet)), "xs"));
method.Statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.GlobalType(typeof(XmlSchemaComplexType)), "type", CodeGenHelper.New(CodeGenHelper.GlobalType(typeof(XmlSchemaComplexType)), new CodeExpression[0])));
method.Statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.GlobalType(typeof(XmlSchemaSequence)), "sequence", CodeGenHelper.New(CodeGenHelper.GlobalType(typeof(XmlSchemaSequence)), new CodeExpression[0])));
method.Statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.Type(this.codeGenerator.DataSourceName), "ds", CodeGenHelper.New(CodeGenHelper.Type(this.codeGenerator.DataSourceName), new CodeExpression[0])));
method.Statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.GlobalType(typeof(XmlSchemaAny)), "any1", CodeGenHelper.New(CodeGenHelper.GlobalType(typeof(XmlSchemaAny)), new CodeExpression[0])));
method.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.Variable("any1"), "Namespace"), CodeGenHelper.Str("http://www.w3.org/2001/XMLSchema")));
method.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.Variable("any1"), "MinOccurs"), CodeGenHelper.New(CodeGenHelper.GlobalType(typeof(decimal)), new CodeExpression[] { CodeGenHelper.Primitive(0) })));
method.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.Variable("any1"), "MaxOccurs"), CodeGenHelper.Field(CodeGenHelper.GlobalTypeExpr(typeof(decimal)), "MaxValue")));
method.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.Variable("any1"), "ProcessContents"), CodeGenHelper.Field(CodeGenHelper.GlobalTypeExpr(typeof(XmlSchemaContentProcessing)), "Lax")));
method.Statements.Add(CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.Variable("sequence"), "Items"), "Add", new CodeExpression[] { CodeGenHelper.Variable("any1") })));
method.Statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.GlobalType(typeof(XmlSchemaAny)), "any2", CodeGenHelper.New(CodeGenHelper.GlobalType(typeof(XmlSchemaAny)), new CodeExpression[0])));
method.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.Variable("any2"), "Namespace"), CodeGenHelper.Str("urn:schemas-microsoft-com:xml-diffgram-v1")));
method.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.Variable("any2"), "MinOccurs"), CodeGenHelper.New(CodeGenHelper.GlobalType(typeof(decimal)), new CodeExpression[] { CodeGenHelper.Primitive(1) })));
method.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.Variable("any2"), "ProcessContents"), CodeGenHelper.Field(CodeGenHelper.GlobalTypeExpr(typeof(XmlSchemaContentProcessing)), "Lax")));
method.Statements.Add(CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.Variable("sequence"), "Items"), "Add", new CodeExpression[] { CodeGenHelper.Variable("any2") })));
method.Statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.GlobalType(typeof(XmlSchemaAttribute)), "attribute1", CodeGenHelper.New(CodeGenHelper.GlobalType(typeof(XmlSchemaAttribute)), new CodeExpression[0])));
method.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.Variable("attribute1"), "Name"), CodeGenHelper.Primitive("namespace")));
method.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.Variable("attribute1"), "FixedValue"), CodeGenHelper.Property(CodeGenHelper.Variable("ds"), "Namespace")));
method.Statements.Add(CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.Variable("type"), "Attributes"), "Add", new CodeExpression[] { CodeGenHelper.Variable("attribute1") })));
method.Statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.GlobalType(typeof(XmlSchemaAttribute)), "attribute2", CodeGenHelper.New(CodeGenHelper.GlobalType(typeof(XmlSchemaAttribute)), new CodeExpression[0])));
method.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.Variable("attribute2"), "Name"), CodeGenHelper.Primitive("tableTypeName")));
method.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.Variable("attribute2"), "FixedValue"), CodeGenHelper.Str(this.designTable.GeneratorTableClassName)));
method.Statements.Add(CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.Variable("type"), "Attributes"), "Add", new CodeExpression[] { CodeGenHelper.Variable("attribute2") })));
method.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.Variable("type"), "Particle"), CodeGenHelper.Variable("sequence")));
DatasetMethodGenerator.GetSchemaIsInCollection(method.Statements, "ds", "xs");
method.Statements.Add(CodeGenHelper.Return(CodeGenHelper.Variable("type")));
return(method);
}
private CodeTypeDeclaration CreateTypedRowEventArg(DesignTable designTable)
{
if (designTable == null)
{
throw new InternalException("DesignTable should not be null.");
}
DataTable dataTable = designTable.DataTable;
string generatorRowClassName = designTable.GeneratorRowClassName;
string generatorTableClassName = designTable.GeneratorTableClassName;
string type = designTable.GeneratorRowClassName;
CodeTypeDeclaration declaration = CodeGenHelper.Class(designTable.GeneratorRowEvArgName, false, TypeAttributes.Public);
declaration.BaseTypes.Add(CodeGenHelper.GlobalType(typeof(EventArgs)));
declaration.Comments.Add(CodeGenHelper.Comment("Row event argument class", true));
declaration.Members.Add(CodeGenHelper.FieldDecl(CodeGenHelper.Type(type), "eventRow"));
declaration.Members.Add(CodeGenHelper.FieldDecl(CodeGenHelper.GlobalType(typeof(DataRowAction)), "eventAction"));
declaration.Members.Add(this.EventArgConstructor(type));
CodeMemberProperty property = CodeGenHelper.PropertyDecl(CodeGenHelper.Type(type), "Row", MemberAttributes.Public | MemberAttributes.Final);
property.GetStatements.Add(CodeGenHelper.Return(CodeGenHelper.Field(CodeGenHelper.This(), "eventRow")));
declaration.Members.Add(property);
property = CodeGenHelper.PropertyDecl(CodeGenHelper.GlobalType(typeof(DataRowAction)), "Action", MemberAttributes.Public | MemberAttributes.Final);
property.GetStatements.Add(CodeGenHelper.Return(CodeGenHelper.Field(CodeGenHelper.This(), "eventAction")));
declaration.Members.Add(property);
return(declaration);
}
private CodeMemberMethod GetRowTypeMethod()
{
CodeMemberMethod method = CodeGenHelper.MethodDecl(CodeGenHelper.GlobalType(typeof(Type)), "GetRowType", MemberAttributes.Family | MemberAttributes.Override);
method.Statements.Add(CodeGenHelper.Return(CodeGenHelper.TypeOf(CodeGenHelper.Type(this.rowConcreteClassName))));
return(method);
}
private CodeMemberMethod CreateInstanceMethod()
{
CodeMemberMethod method = CodeGenHelper.MethodDecl(CodeGenHelper.GlobalType(typeof(DataTable)), "CreateInstance", MemberAttributes.Family | MemberAttributes.Override);
method.Statements.Add(CodeGenHelper.Return(CodeGenHelper.New(CodeGenHelper.Type(this.tableClassName), new CodeExpression[0])));
return(method);
}
private CodeMemberMethod RemoveRowMethod()
{
CodeMemberMethod method = CodeGenHelper.MethodDecl(CodeGenHelper.GlobalType(typeof(void)), NameHandler.FixIdName("Remove" + this.rowClassName), MemberAttributes.Public | MemberAttributes.Final);
method.Parameters.Add(CodeGenHelper.ParameterDecl(CodeGenHelper.Type(this.rowConcreteClassName), "row"));
method.Statements.Add(CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.This(), "Rows"), "Remove", CodeGenHelper.Argument("row")));
return(method);
}
private CodeMemberMethod NewRowFromBuilderMethod()
{
CodeMemberMethod method = CodeGenHelper.MethodDecl(CodeGenHelper.GlobalType(typeof(DataRow)), "NewRowFromBuilder", MemberAttributes.Family | MemberAttributes.Override);
method.Parameters.Add(CodeGenHelper.ParameterDecl(CodeGenHelper.GlobalType(typeof(DataRowBuilder)), "builder"));
method.Statements.Add(CodeGenHelper.Return(CodeGenHelper.New(CodeGenHelper.Type(this.rowConcreteClassName), new CodeExpression[] { CodeGenHelper.Argument("builder") })));
return(method);
}
private CodeMemberProperty IndexProperty(DesignTable designTable)
{
string generatorRowClassName = designTable.GeneratorRowClassName;
CodeMemberProperty property = CodeGenHelper.PropertyDecl(CodeGenHelper.Type(generatorRowClassName), "Item", MemberAttributes.Public | MemberAttributes.Final);
property.Parameters.Add(CodeGenHelper.ParameterDecl(CodeGenHelper.GlobalType(typeof(int)), "index"));
property.GetStatements.Add(CodeGenHelper.Return(CodeGenHelper.Cast(CodeGenHelper.Type(generatorRowClassName), CodeGenHelper.Indexer(CodeGenHelper.Property(CodeGenHelper.This(), "Rows"), CodeGenHelper.Argument("index")))));
return(property);
}
private CodeMemberMethod CloneMethod()
{
CodeMemberMethod method = CodeGenHelper.MethodDecl(CodeGenHelper.GlobalType(typeof(DataTable)), "Clone", MemberAttributes.Public | MemberAttributes.Override);
method.Statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.Type(this.tableClassName), "cln", CodeGenHelper.Cast(CodeGenHelper.Type(this.tableClassName), CodeGenHelper.MethodCall(CodeGenHelper.Base(), "Clone", new CodeExpression[0]))));
method.Statements.Add(CodeGenHelper.MethodCall(CodeGenHelper.Variable("cln"), "InitVars", new CodeExpression[0]));
method.Statements.Add(CodeGenHelper.Return(CodeGenHelper.Variable("cln")));
return(method);
}
private CodeConstructor EventArgConstructor(string rowConcreteClassName)
{
CodeConstructor constructor = CodeGenHelper.Constructor(MemberAttributes.Public | MemberAttributes.Final);
constructor.Parameters.Add(CodeGenHelper.ParameterDecl(CodeGenHelper.Type(rowConcreteClassName), "row"));
constructor.Parameters.Add(CodeGenHelper.ParameterDecl(CodeGenHelper.GlobalType(typeof(DataRowAction)), "action"));
constructor.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Field(CodeGenHelper.This(), "eventRow"), CodeGenHelper.Argument("row")));
constructor.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Field(CodeGenHelper.This(), "eventAction"), CodeGenHelper.Argument("action")));
return(constructor);
}
internal void AddPrivateVars(CodeTypeDeclaration dataSourceClass)
{
if (this.tables != null)
{
foreach (DesignTable table in this.tables)
{
string generatorTableClassName = table.GeneratorTableClassName;
string generatorTableVarName = table.GeneratorTableVarName;
dataSourceClass.Members.Add(CodeGenHelper.FieldDecl(CodeGenHelper.Type(generatorTableClassName), generatorTableVarName));
}
}
}
private void AddParametersToMethod(CodeMemberMethod dbMethod)
{
DesignConnection connection = (DesignConnection)base.methodSource.Connection;
if (connection == null)
{
throw new InternalException(string.Format(CultureInfo.CurrentCulture, "Connection for query {0} is null.", new object[] { base.methodSource.Name }));
}
string parameterPrefix = connection.ParameterPrefix;
if (base.MethodType == MethodTypeEnum.ColumnParameters)
{
if (base.activeCommand.Parameters != null)
{
CodeParameterDeclarationExpression expression = null;
foreach (DesignParameter parameter in base.activeCommand.Parameters)
{
if (((parameter.Direction != ParameterDirection.ReturnValue) && !parameter.SourceColumnNullMapping) && ((!this.GenerateOverloadWithoutCurrentPKParameters || (parameter.SourceVersion != DataRowVersion.Current)) || (!this.IsPrimaryColumn(parameter.SourceColumn) || (this.GetOriginalVersionParameter(parameter) == null))))
{
Type parameterUrtType = base.GetParameterUrtType(parameter);
string name = base.nameHandler.AddParameterNameToList(parameter.ParameterName, parameterPrefix);
CodeTypeReference type = null;
if (parameter.AllowDbNull && parameterUrtType.IsValueType)
{
type = CodeGenHelper.NullableType(parameterUrtType);
}
else
{
type = CodeGenHelper.Type(parameterUrtType);
}
expression = CodeGenHelper.ParameterDecl(type, name);
expression.Direction = CodeGenHelper.ParameterDirectionToFieldDirection(parameter.Direction);
dbMethod.Parameters.Add(expression);
}
}
}
}
else
{
CodeParameterDeclarationExpression expression2 = null;
string str3 = base.nameHandler.AddParameterNameToList(base.UpdateParameterName, parameterPrefix);
if (base.UpdateParameterTypeName != null)
{
expression2 = CodeGenHelper.ParameterDecl(CodeGenHelper.Type(base.UpdateParameterTypeName), str3);
}
else
{
expression2 = CodeGenHelper.ParameterDecl(base.UpdateParameterTypeReference, str3);
}
dbMethod.Parameters.Add(expression2);
}
}
private CodeMemberMethod GenerateInternal()
{
DesignParameter returnParameter = base.GetReturnParameter(base.activeCommand);
CodeTypeReference type = null;
if (base.methodSource.QueryType == QueryType.Scalar)
{
base.returnType = base.methodSource.ScalarCallRetval;
if (base.returnType.IsValueType)
{
type = CodeGenHelper.NullableType(base.returnType);
}
else
{
type = CodeGenHelper.Type(base.returnType);
}
}
else if ((base.methodSource.DbObjectType == DbObjectType.Function) && (returnParameter != null))
{
base.returnType = base.GetParameterUrtType(returnParameter);
if (returnParameter.AllowDbNull && base.returnType.IsValueType)
{
type = CodeGenHelper.NullableType(base.returnType);
}
else
{
type = CodeGenHelper.Type(base.returnType);
}
}
else
{
base.returnType = typeof(int);
type = CodeGenHelper.Type(base.returnType);
}
CodeMemberMethod dbMethod = null;
dbMethod = CodeGenHelper.MethodDecl(type, base.MethodName, base.methodAttributes);
dbMethod.CustomAttributes.Add(CodeGenHelper.AttributeDecl(typeof(HelpKeywordAttribute).FullName, CodeGenHelper.Str("vs.data.TableAdapter")));
this.AddParametersToMethod(dbMethod);
if (base.declarationOnly)
{
base.AddThrowsClauseIfNeeded(dbMethod);
return(dbMethod);
}
this.AddCustomAttributesToMethod(dbMethod);
if (this.AddStatementsToMethod(dbMethod))
{
return(dbMethod);
}
return(null);
}
private CodeMemberMethod CloneMethod(CodeMemberMethod initExpressionsMethod)
{
CodeMemberMethod method = CodeGenHelper.MethodDecl(CodeGenHelper.GlobalType(typeof(DataSet)), "Clone", MemberAttributes.Public | MemberAttributes.Override);
method.Statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.Type(this.codeGenerator.DataSourceName), "cln", CodeGenHelper.Cast(CodeGenHelper.Type(this.codeGenerator.DataSourceName), CodeGenHelper.MethodCall(CodeGenHelper.Base(), "Clone", new CodeExpression[0]))));
method.Statements.Add(CodeGenHelper.MethodCall(CodeGenHelper.Variable("cln"), "InitVars", new CodeExpression[0]));
if (initExpressionsMethod != null)
{
method.Statements.Add(CodeGenHelper.MethodCall(CodeGenHelper.Variable("cln"), "InitExpressions", new CodeExpression[0]));
}
method.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.Variable("cln"), "SchemaSerializationMode"), CodeGenHelper.Property(CodeGenHelper.This(), "SchemaSerializationMode")));
method.Statements.Add(CodeGenHelper.Return(CodeGenHelper.Variable("cln")));
return(method);
}
private void AddParametersToMethod(CodeMemberMethod dbMethod)
{
CodeParameterDeclarationExpression expression = null;
if (!base.getMethod)
{
string name = base.nameHandler.AddNameToList(base.ContainerParameterName);
expression = CodeGenHelper.ParameterDecl(CodeGenHelper.Type(base.ContainerParameterTypeName), name);
dbMethod.Parameters.Add(expression);
}
if (base.GeneratePagingMethod)
{
string str2 = base.nameHandler.AddNameToList(QueryGeneratorBase.startRecordParameterName);
expression = CodeGenHelper.ParameterDecl(CodeGenHelper.GlobalType(typeof(int)), str2);
dbMethod.Parameters.Add(expression);
string str3 = base.nameHandler.AddNameToList(QueryGeneratorBase.maxRecordsParameterName);
expression = CodeGenHelper.ParameterDecl(CodeGenHelper.GlobalType(typeof(int)), str3);
dbMethod.Parameters.Add(expression);
}
if (base.activeCommand.Parameters != null)
{
DesignConnection connection = (DesignConnection)base.methodSource.Connection;
if (connection == null)
{
throw new InternalException(string.Format(CultureInfo.CurrentCulture, "Connection for query {0} is null.", new object[] { base.methodSource.Name }));
}
string parameterPrefix = connection.ParameterPrefix;
foreach (DesignParameter parameter in base.activeCommand.Parameters)
{
if (parameter.Direction != ParameterDirection.ReturnValue)
{
Type parameterUrtType = base.GetParameterUrtType(parameter);
string str5 = base.nameHandler.AddParameterNameToList(parameter.ParameterName, parameterPrefix);
CodeTypeReference type = null;
if (parameter.AllowDbNull && parameterUrtType.IsValueType)
{
type = CodeGenHelper.NullableType(parameterUrtType);
}
else
{
type = CodeGenHelper.Type(parameterUrtType);
}
expression = CodeGenHelper.ParameterDecl(type, str5);
expression.Direction = CodeGenHelper.ParameterDirectionToFieldDirection(parameter.Direction);
dbMethod.Parameters.Add(expression);
}
}
}
}
private CodeMemberMethod GetTypedDataSetSchema()
{
CodeMemberMethod method = CodeGenHelper.MethodDecl(CodeGenHelper.GlobalType(typeof(XmlSchemaComplexType)), "GetTypedDataSetSchema", MemberAttributes.Public | MemberAttributes.Static);
method.Parameters.Add(CodeGenHelper.ParameterDecl(CodeGenHelper.GlobalType(typeof(XmlSchemaSet)), "xs"));
method.Statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.Type(this.dataSource.GeneratorDataSetName), "ds", CodeGenHelper.New(CodeGenHelper.Type(this.dataSource.GeneratorDataSetName), new CodeExpression[0])));
method.Statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.GlobalType(typeof(XmlSchemaComplexType)), "type", CodeGenHelper.New(CodeGenHelper.GlobalType(typeof(XmlSchemaComplexType)), new CodeExpression[0])));
method.Statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.GlobalType(typeof(XmlSchemaSequence)), "sequence", CodeGenHelper.New(CodeGenHelper.GlobalType(typeof(XmlSchemaSequence)), new CodeExpression[0])));
method.Statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.GlobalType(typeof(XmlSchemaAny)), "any", CodeGenHelper.New(CodeGenHelper.GlobalType(typeof(XmlSchemaAny)), new CodeExpression[0])));
method.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.Variable("any"), "Namespace"), CodeGenHelper.Property(CodeGenHelper.Variable("ds"), "Namespace")));
method.Statements.Add(CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.Variable("sequence"), "Items"), "Add", new CodeExpression[] { CodeGenHelper.Variable("any") })));
method.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.Variable("type"), "Particle"), CodeGenHelper.Variable("sequence")));
GetSchemaIsInCollection(method.Statements, "ds", "xs");
method.Statements.Add(CodeGenHelper.Return(CodeGenHelper.Variable("type")));
return(method);
}
internal void AddTableProperties(CodeTypeDeclaration dataSourceClass)
{
if (this.tables != null)
{
foreach (DesignTable table in this.tables)
{
string generatorTableClassName = table.GeneratorTableClassName;
string generatorTablePropName = table.GeneratorTablePropName;
string generatorTableVarName = table.GeneratorTableVarName;
CodeMemberProperty property = CodeGenHelper.PropertyDecl(CodeGenHelper.Type(generatorTableClassName), generatorTablePropName, MemberAttributes.Public | MemberAttributes.Final);
property.CustomAttributes.Add(CodeGenHelper.AttributeDecl("System.ComponentModel.Browsable", CodeGenHelper.Primitive(false)));
property.CustomAttributes.Add(CodeGenHelper.AttributeDecl("System.ComponentModel.DesignerSerializationVisibility", CodeGenHelper.Field(CodeGenHelper.GlobalTypeExpr(typeof(DesignerSerializationVisibility)), "Content")));
property.GetStatements.Add(CodeGenHelper.Return(CodeGenHelper.Field(CodeGenHelper.This(), generatorTableVarName)));
dataSourceClass.Members.Add(property);
}
}
}
private CodeMemberMethod GenerateInternal()
{
CodeMemberMethod dbMethod = null;
dbMethod = CodeGenHelper.MethodDecl(CodeGenHelper.Type(base.returnType), base.MethodName, base.methodAttributes);
dbMethod.CustomAttributes.Add(CodeGenHelper.AttributeDecl(typeof(HelpKeywordAttribute).FullName, CodeGenHelper.Str("vs.data.TableAdapter")));
this.AddParametersToMethod(dbMethod);
if (base.declarationOnly)
{
return(dbMethod);
}
this.AddCustomAttributesToMethod(dbMethod);
if (this.AddStatementsToMethod(dbMethod))
{
return(dbMethod);
}
return(null);
}
private CodeTypeDelegate GenerateTypedRowEventHandler(DesignTable table)
{
CodeTypeDelegate delegate2;
if (table == null)
{
throw new InternalException("DesignTable should not be null.");
}
string generatorRowClassName = table.GeneratorRowClassName;
delegate2 = new CodeTypeDelegate(table.GeneratorRowEvHandlerName)
{
TypeAttributes = delegate2.TypeAttributes | TypeAttributes.Public
};
delegate2.Parameters.Add(CodeGenHelper.ParameterDecl(CodeGenHelper.GlobalType(typeof(object)), "sender"));
delegate2.Parameters.Add(CodeGenHelper.ParameterDecl(CodeGenHelper.Type(table.GeneratorRowEvArgName), "e"));
delegate2.CustomAttributes.Add(CodeGenHelper.GeneratedCodeAttributeDecl());
return(delegate2);
}
private CodeTypeDeclaration GenerateRow(DesignTable table)
{
if (table == null)
{
throw new InternalException("DesignTable should not be null.");
}
string generatorRowClassName = table.GeneratorRowClassName;
string generatorTableClassName = table.GeneratorTableClassName;
string generatorTableVarName = table.GeneratorTableVarName;
TypedColumnHandler columnHandler = this.codeGenerator.TableHandler.GetColumnHandler(table.Name);
CodeTypeDeclaration rowClass = CodeGenHelper.Class(generatorRowClassName, true, TypeAttributes.Public);
rowClass.BaseTypes.Add(CodeGenHelper.GlobalType(typeof(DataRow)));
rowClass.Comments.Add(CodeGenHelper.Comment("Represents strongly named DataRow class.", true));
rowClass.Members.Add(CodeGenHelper.FieldDecl(CodeGenHelper.Type(generatorTableClassName), generatorTableVarName));
rowClass.Members.Add(this.RowConstructor(generatorTableClassName, generatorTableVarName));
columnHandler.AddRowColumnProperties(rowClass);
columnHandler.AddRowGetRelatedRowsMethods(rowClass);
return(rowClass);
}
private bool AddExecuteCommandStatements(IList statements)
{
if (base.getMethod)
{
CodeExpression[] expressionArray = new CodeExpression[0];
if ((base.designTable != null) && base.designTable.HasAnyExpressionColumn)
{
expressionArray = new CodeExpression[] { CodeGenHelper.Primitive(true) };
}
statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.Type(base.ContainerParameterTypeName), base.ContainerParameterName, CodeGenHelper.New(CodeGenHelper.Type(base.ContainerParameterTypeName), expressionArray)));
}
CodeExpression[] parameters = new CodeExpression[] { CodeGenHelper.Variable(base.ContainerParameterName) };
if (!base.getMethod)
{
statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.GlobalType(typeof(int)), QueryGeneratorBase.returnVariableName, CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.This(), DataComponentNameHandler.AdapterPropertyName), "Fill", parameters)));
}
else
{
statements.Add(CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.This(), DataComponentNameHandler.AdapterPropertyName), "Fill", parameters)));
}
return(true);
}
private void AddFindByMethods(CodeTypeDeclaration dataTableClass)
{
DataTable dataTable = this.designTable.DataTable;
for (int i = 0; i < dataTable.Constraints.Count; i++)
{
if ((dataTable.Constraints[i] is UniqueConstraint) && ((UniqueConstraint)dataTable.Constraints[i]).IsPrimaryKey)
{
DataColumn[] columns = ((UniqueConstraint)dataTable.Constraints[i]).Columns;
string inVarName = "FindBy";
bool flag = true;
for (int j = 0; j < columns.Length; j++)
{
inVarName = inVarName + this.codeGenerator.TableHandler.Tables[columns[j].Table.TableName].DesignColumns[columns[j].ColumnName].GeneratorColumnPropNameInRow;
if (columns[j].ColumnMapping != MappingType.Hidden)
{
flag = false;
}
}
if (!flag)
{
CodeMemberMethod method = CodeGenHelper.MethodDecl(CodeGenHelper.Type(this.rowClassName), NameHandler.FixIdName(inVarName), MemberAttributes.Public | MemberAttributes.Final);
for (int k = 0; k < columns.Length; k++)
{
method.Parameters.Add(CodeGenHelper.ParameterDecl(CodeGenHelper.Type(columns[k].DataType), this.codeGenerator.TableHandler.Tables[columns[k].Table.TableName].DesignColumns[columns[k].ColumnName].GeneratorColumnPropNameInRow));
}
CodeArrayCreateExpression par = new CodeArrayCreateExpression(typeof(object), columns.Length);
for (int m = 0; m < columns.Length; m++)
{
par.Initializers.Add(CodeGenHelper.Argument(this.codeGenerator.TableHandler.Tables[columns[m].Table.TableName].DesignColumns[columns[m].ColumnName].GeneratorColumnPropNameInRow));
}
method.Statements.Add(CodeGenHelper.Return(CodeGenHelper.Cast(CodeGenHelper.Type(this.rowClassName), CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.This(), "Rows"), "Find", par))));
dataTableClass.Members.Add(method);
}
}
}
}
internal void AddRowGetRelatedRowsMethods(CodeTypeDeclaration rowClass)
{
DataRelationCollection childRelations = this.table.ChildRelations;
for (int i = 0; i < childRelations.Count; i++)
{
DataRelation relation = childRelations[i];
string generatorRowClassName = this.codeGenerator.TableHandler.Tables[relation.ChildTable.TableName].GeneratorRowClassName;
CodeMemberMethod method = CodeGenHelper.MethodDecl(CodeGenHelper.Type(generatorRowClassName, 1), this.codeGenerator.RelationHandler.Relations[relation.RelationName].GeneratorChildPropName, MemberAttributes.Public | MemberAttributes.Final);
method.Statements.Add(CodeGenHelper.If(CodeGenHelper.IdEQ(CodeGenHelper.Indexer(CodeGenHelper.Property(CodeGenHelper.Property(CodeGenHelper.This(), "Table"), "ChildRelations"), CodeGenHelper.Str(relation.RelationName)), CodeGenHelper.Primitive(null)), CodeGenHelper.Return(new CodeArrayCreateExpression(generatorRowClassName, 0)), CodeGenHelper.Return(CodeGenHelper.Cast(CodeGenHelper.Type(generatorRowClassName, 1), CodeGenHelper.MethodCall(CodeGenHelper.Base(), "GetChildRows", CodeGenHelper.Indexer(CodeGenHelper.Property(CodeGenHelper.Property(CodeGenHelper.This(), "Table"), "ChildRelations"), CodeGenHelper.Str(relation.RelationName)))))));
rowClass.Members.Add(method);
}
DataRelationCollection parentRelations = this.table.ParentRelations;
for (int j = 0; j < parentRelations.Count; j++)
{
DataRelation relation2 = parentRelations[j];
string type = this.codeGenerator.TableHandler.Tables[relation2.ParentTable.TableName].GeneratorRowClassName;
CodeMemberProperty property = CodeGenHelper.PropertyDecl(CodeGenHelper.Type(type), this.codeGenerator.RelationHandler.Relations[relation2.RelationName].GeneratorParentPropName, MemberAttributes.Public | MemberAttributes.Final);
property.GetStatements.Add(CodeGenHelper.Return(CodeGenHelper.Cast(CodeGenHelper.Type(type), CodeGenHelper.MethodCall(CodeGenHelper.This(), "GetParentRow", CodeGenHelper.Indexer(CodeGenHelper.Property(CodeGenHelper.Property(CodeGenHelper.This(), "Table"), "ParentRelations"), CodeGenHelper.Str(relation2.RelationName))))));
property.SetStatements.Add(CodeGenHelper.MethodCall(CodeGenHelper.This(), "SetParentRow", new CodeExpression[] { CodeGenHelper.Value(), CodeGenHelper.Indexer(CodeGenHelper.Property(CodeGenHelper.Property(CodeGenHelper.This(), "Table"), "ParentRelations"), CodeGenHelper.Str(relation2.RelationName)) }));
rowClass.Members.Add(property);
}
}
private bool AddExecuteCommandStatementsForPaging(IList statements)
{
if (base.containerParamType == typeof(DataTable))
{
statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.Type(base.codeGenerator.DataSourceName), base.nameHandler.AddNameToList("dataSet"), CodeGenHelper.New(CodeGenHelper.Type(base.codeGenerator.DataSourceName), new CodeExpression[0])));
}
CodeExpression[] parameters = new CodeExpression[4];
if (base.containerParamType == typeof(DataTable))
{
parameters[0] = CodeGenHelper.Variable(base.nameHandler.GetNameFromList("dataSet"));
}
else
{
parameters[0] = CodeGenHelper.Argument(base.ContainerParameterName);
}
parameters[1] = CodeGenHelper.Argument(base.nameHandler.GetNameFromList(QueryGeneratorBase.startRecordParameterName));
parameters[2] = CodeGenHelper.Argument(base.nameHandler.GetNameFromList(QueryGeneratorBase.maxRecordsParameterName));
parameters[3] = CodeGenHelper.Str("Table");
if (!base.getMethod)
{
statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.GlobalType(typeof(int)), QueryGeneratorBase.returnVariableName, CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.This(), DataComponentNameHandler.AdapterPropertyName), "Fill", parameters)));
}
else
{
statements.Add(CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.This(), DataComponentNameHandler.AdapterPropertyName), "Fill", parameters)));
}
if ((base.containerParamType == typeof(DataTable)) && !base.getMethod)
{
CodeStatement initStmt = CodeGenHelper.VariableDecl(CodeGenHelper.GlobalType(typeof(int)), "i", CodeGenHelper.Primitive(0));
CodeExpression testExpression = CodeGenHelper.Less(CodeGenHelper.Variable("i"), CodeGenHelper.Property(CodeGenHelper.Property(CodeGenHelper.Property(CodeGenHelper.Variable(base.nameHandler.GetNameFromList("dataSet")), base.DesignTable.GeneratorName), "Rows"), "Count"));
CodeStatement incrementStmt = CodeGenHelper.Assign(CodeGenHelper.Variable("i"), CodeGenHelper.BinOperator(CodeGenHelper.Variable("i"), CodeBinaryOperatorType.Add, CodeGenHelper.Primitive(1)));
CodeStatement statement3 = CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.Argument(base.ContainerParameterName), "ImportRow", new CodeExpression[] { CodeGenHelper.Indexer(CodeGenHelper.Property(CodeGenHelper.Property(CodeGenHelper.Variable(base.nameHandler.GetNameFromList("dataSet")), base.DesignTable.GeneratorName), "Rows"), CodeGenHelper.Variable("i")) }));
statements.Add(CodeGenHelper.ForLoop(initStmt, testExpression, incrementStmt, new CodeStatement[] { statement3 }));
}
return(true);
}
internal void AddRowColumnProperties(CodeTypeDeclaration rowClass)
{
bool flag = false;
string generatorRowClassName = this.codeGenerator.TableHandler.Tables[this.table.TableName].GeneratorRowClassName;
string generatorTableVarName = this.codeGenerator.TableHandler.Tables[this.table.TableName].GeneratorTableVarName;
foreach (DesignColumn column in this.columns)
{
CodeExpression expression;
CodeExpression expression2;
DataColumn dataColumn = column.DataColumn;
Type dataType = dataColumn.DataType;
string generatorColumnPropNameInRow = column.GeneratorColumnPropNameInRow;
string generatorColumnPropNameInTable = column.GeneratorColumnPropNameInTable;
GenericNameHandler handler = new GenericNameHandler(new string[] { generatorColumnPropNameInRow }, this.codeGenerator.CodeProvider);
CodeMemberProperty property = CodeGenHelper.PropertyDecl(CodeGenHelper.Type(dataType), generatorColumnPropNameInRow, MemberAttributes.Public | MemberAttributes.Final);
CodeStatement tryStmnt = CodeGenHelper.Return(CodeGenHelper.Cast(CodeGenHelper.GlobalType(dataType), CodeGenHelper.Indexer(CodeGenHelper.This(), CodeGenHelper.Property(CodeGenHelper.Field(CodeGenHelper.This(), generatorTableVarName), generatorColumnPropNameInTable))));
if (!dataColumn.AllowDBNull)
{
goto Label_0440;
}
string str5 = (string)dataColumn.ExtendedProperties["nullValue"];
switch (str5)
{
case null:
case "_throw":
tryStmnt = CodeGenHelper.Try(tryStmnt, CodeGenHelper.Catch(CodeGenHelper.GlobalType(typeof(InvalidCastException)), handler.AddNameToList("e"), CodeGenHelper.Throw(CodeGenHelper.GlobalType(typeof(StrongTypingException)), System.Design.SR.GetString("CG_ColumnIsDBNull", new object[] { dataColumn.ColumnName, this.table.TableName }), handler.GetNameFromList("e"))));
goto Label_0440;
default:
{
expression = null;
switch (str5)
{
case "_null":
if (dataColumn.DataType.IsSubclassOf(typeof(System.ValueType)))
{
this.codeGenerator.ProblemList.Add(new DSGeneratorProblem(System.Design.SR.GetString("CG_TypeCantBeNull", new object[] { dataColumn.ColumnName, dataColumn.DataType.Name }), ProblemSeverity.NonFatalError, column));
continue;
}
expression2 = CodeGenHelper.Primitive(null);
goto Label_03AE;
case "_empty":
if (dataColumn.DataType == typeof(string))
{
expression2 = CodeGenHelper.Property(CodeGenHelper.TypeExpr(CodeGenHelper.GlobalType(dataColumn.DataType)), "Empty");
}
else
{
expression2 = CodeGenHelper.Field(CodeGenHelper.TypeExpr(CodeGenHelper.Type(generatorRowClassName)), generatorColumnPropNameInRow + "_nullValue");
ConstructorInfo constructor = dataColumn.DataType.GetConstructor(new Type[] { typeof(string) });
if (constructor == null)
{
this.codeGenerator.ProblemList.Add(new DSGeneratorProblem(System.Design.SR.GetString("CG_NoCtor0", new object[] { dataColumn.ColumnName, dataColumn.DataType.Name }), ProblemSeverity.NonFatalError, column));
continue;
}
constructor.Invoke(new object[0]);
expression = CodeGenHelper.New(CodeGenHelper.Type(dataColumn.DataType), new CodeExpression[0]);
}
goto Label_03AE;
}
if (!flag)
{
this.table.NewRow();
flag = true;
}
object valueObj = this.codeGenerator.RowHandler.RowGenerator.ConvertXmlToObject.Invoke(dataColumn, new object[] { str5 });
DSGeneratorProblem problem = CodeGenHelper.GenerateValueExprAndFieldInit(column, valueObj, str5, generatorRowClassName, generatorColumnPropNameInRow + "_nullValue", out expression2, out expression);
if (problem != null)
{
this.codeGenerator.ProblemList.Add(problem);
continue;
}
break;
}
}
Label_03AE :;
tryStmnt = CodeGenHelper.If(CodeGenHelper.MethodCall(CodeGenHelper.This(), "Is" + generatorColumnPropNameInRow + "Null"), new CodeStatement[] { CodeGenHelper.Return(expression2) }, new CodeStatement[] { tryStmnt });
if (expression != null)
{
CodeMemberField field = CodeGenHelper.FieldDecl(CodeGenHelper.Type(dataColumn.DataType.FullName), generatorColumnPropNameInRow + "_nullValue");
field.Attributes = MemberAttributes.Private | MemberAttributes.Static;
field.InitExpression = expression;
rowClass.Members.Add(field);
}
Label_0440:
property.GetStatements.Add(tryStmnt);
property.SetStatements.Add(CodeGenHelper.Assign(CodeGenHelper.Indexer(CodeGenHelper.This(), CodeGenHelper.Property(CodeGenHelper.Field(CodeGenHelper.This(), generatorTableVarName), generatorColumnPropNameInTable)), CodeGenHelper.Value()));
rowClass.Members.Add(property);
if (dataColumn.AllowDBNull)
{
string name = MemberNameValidator.GenerateIdName("Is" + generatorColumnPropNameInRow + "Null", this.codeGenerator.CodeProvider, false);
CodeMemberMethod method = CodeGenHelper.MethodDecl(CodeGenHelper.GlobalType(typeof(bool)), name, MemberAttributes.Public | MemberAttributes.Final);
method.Statements.Add(CodeGenHelper.Return(CodeGenHelper.MethodCall(CodeGenHelper.This(), "IsNull", CodeGenHelper.Property(CodeGenHelper.Field(CodeGenHelper.This(), generatorTableVarName), generatorColumnPropNameInTable))));
rowClass.Members.Add(method);
name = MemberNameValidator.GenerateIdName("Set" + generatorColumnPropNameInRow + "Null", this.codeGenerator.CodeProvider, false);
CodeMemberMethod method2 = CodeGenHelper.MethodDecl(CodeGenHelper.GlobalType(typeof(void)), name, MemberAttributes.Public | MemberAttributes.Final);
method2.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Indexer(CodeGenHelper.This(), CodeGenHelper.Property(CodeGenHelper.Field(CodeGenHelper.This(), generatorTableVarName), generatorColumnPropNameInTable)), CodeGenHelper.Field(CodeGenHelper.GlobalTypeExpr(typeof(Convert)), "DBNull")));
rowClass.Members.Add(method2);
}
}
}
private CodeMemberMethod ReadXmlSerializableMethod()
{
CodeMemberMethod method = CodeGenHelper.MethodDecl(CodeGenHelper.GlobalType(typeof(void)), "ReadXmlSerializable", MemberAttributes.Family | MemberAttributes.Override);
method.Parameters.Add(CodeGenHelper.ParameterDecl(CodeGenHelper.GlobalType(typeof(XmlReader)), "reader"));
ArrayList list = new ArrayList();
ArrayList list2 = new ArrayList();
list.Add(CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.This(), "Reset", new CodeExpression[0])));
list.Add(CodeGenHelper.VariableDecl(CodeGenHelper.GlobalType(typeof(DataSet)), "ds", CodeGenHelper.New(CodeGenHelper.GlobalType(typeof(DataSet)), new CodeExpression[0])));
list.Add(CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.Variable("ds"), "ReadXml", new CodeExpression[] { CodeGenHelper.Argument("reader") })));
foreach (DesignTable table in this.codeGenerator.TableHandler.Tables)
{
list.Add(CodeGenHelper.If(CodeGenHelper.IdNotEQ(CodeGenHelper.Indexer(CodeGenHelper.Property(CodeGenHelper.Variable("ds"), "Tables"), CodeGenHelper.Str(table.Name)), CodeGenHelper.Primitive(null)), CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.Base(), "Tables"), "Add", CodeGenHelper.New(CodeGenHelper.Type(table.GeneratorTableClassName), new CodeExpression[] { CodeGenHelper.Indexer(CodeGenHelper.Property(CodeGenHelper.Variable("ds"), "Tables"), CodeGenHelper.Str(table.Name)) })))));
}
list.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.This(), "DataSetName"), CodeGenHelper.Property(CodeGenHelper.Variable("ds"), "DataSetName")));
list.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.This(), "Prefix"), CodeGenHelper.Property(CodeGenHelper.Variable("ds"), "Prefix")));
list.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.This(), "Namespace"), CodeGenHelper.Property(CodeGenHelper.Variable("ds"), "Namespace")));
list.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.This(), "Locale"), CodeGenHelper.Property(CodeGenHelper.Variable("ds"), "Locale")));
list.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.This(), "CaseSensitive"), CodeGenHelper.Property(CodeGenHelper.Variable("ds"), "CaseSensitive")));
list.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.This(), "EnforceConstraints"), CodeGenHelper.Property(CodeGenHelper.Variable("ds"), "EnforceConstraints")));
list.Add(CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.This(), "Merge", new CodeExpression[] { CodeGenHelper.Variable("ds"), CodeGenHelper.Primitive(false), CodeGenHelper.Field(CodeGenHelper.GlobalTypeExpr(typeof(MissingSchemaAction)), "Add") })));
list.Add(CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.This(), "InitVars")));
list2.Add(CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.This(), "ReadXml", new CodeExpression[] { CodeGenHelper.Argument("reader") })));
list2.Add(CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.This(), "InitVars")));
method.Statements.Add(CodeGenHelper.If(CodeGenHelper.EQ(CodeGenHelper.MethodCall(CodeGenHelper.This(), "DetermineSchemaSerializationMode", new CodeExpression[] { CodeGenHelper.Argument("reader") }), CodeGenHelper.Field(CodeGenHelper.GlobalTypeExpr(typeof(SchemaSerializationMode)), "IncludeSchema")), (CodeStatement[])list.ToArray(typeof(CodeStatement)), (CodeStatement[])list2.ToArray(typeof(CodeStatement))));
return(method);
}
private void InitClassAndInitVarsMethods(out CodeMemberMethod initClassMethod, out CodeMemberMethod initVarsMethod)
{
initClassMethod = CodeGenHelper.MethodDecl(CodeGenHelper.GlobalType(typeof(void)), "InitClass", MemberAttributes.Private);
initVarsMethod = CodeGenHelper.MethodDecl(CodeGenHelper.GlobalType(typeof(void)), "InitVars", MemberAttributes.Assembly | MemberAttributes.Final);
initVarsMethod.Parameters.Add(CodeGenHelper.ParameterDecl(CodeGenHelper.GlobalType(typeof(bool)), "initTable"));
initClassMethod.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.This(), "DataSetName"), CodeGenHelper.Str(this.dataSet.DataSetName)));
initClassMethod.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.This(), "Prefix"), CodeGenHelper.Str(this.dataSet.Prefix)));
if (namespaceProperty.ShouldSerializeValue(this.dataSet))
{
initClassMethod.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.This(), "Namespace"), CodeGenHelper.Str(this.dataSet.Namespace)));
}
if (localeProperty.ShouldSerializeValue(this.dataSet))
{
initClassMethod.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.This(), "Locale"), CodeGenHelper.New(CodeGenHelper.GlobalType(typeof(CultureInfo)), new CodeExpression[] { CodeGenHelper.Str(this.dataSet.Locale.ToString()) })));
}
if (caseSensitiveProperty.ShouldSerializeValue(this.dataSet))
{
initClassMethod.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.This(), "CaseSensitive"), CodeGenHelper.Primitive(this.dataSet.CaseSensitive)));
}
initClassMethod.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.This(), "EnforceConstraints"), CodeGenHelper.Primitive(this.dataSet.EnforceConstraints)));
initClassMethod.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(CodeGenHelper.This(), "SchemaSerializationMode"), CodeGenHelper.Field(CodeGenHelper.GlobalTypeExpr(typeof(SchemaSerializationMode)), this.dataSource.SchemaSerializationMode.ToString())));
foreach (DesignTable table in this.codeGenerator.TableHandler.Tables)
{
CodeExpression expression = CodeGenHelper.Field(CodeGenHelper.This(), table.GeneratorTableVarName);
if (this.TableContainsExpressions(table))
{
initClassMethod.Statements.Add(CodeGenHelper.Assign(expression, CodeGenHelper.New(CodeGenHelper.Type(table.GeneratorTableClassName), new CodeExpression[] { CodeGenHelper.Primitive(false) })));
}
else
{
initClassMethod.Statements.Add(CodeGenHelper.Assign(expression, CodeGenHelper.New(CodeGenHelper.Type(table.GeneratorTableClassName), new CodeExpression[0])));
}
initClassMethod.Statements.Add(CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.Base(), "Tables"), "Add", expression));
initVarsMethod.Statements.Add(CodeGenHelper.Assign(expression, CodeGenHelper.Cast(CodeGenHelper.Type(table.GeneratorTableClassName), CodeGenHelper.Indexer(CodeGenHelper.Property(CodeGenHelper.Base(), "Tables"), CodeGenHelper.Str(table.Name)))));
initVarsMethod.Statements.Add(CodeGenHelper.If(CodeGenHelper.EQ(CodeGenHelper.Variable("initTable"), CodeGenHelper.Primitive(true)), new CodeStatement[] { CodeGenHelper.If(CodeGenHelper.IdNotEQ(expression, CodeGenHelper.Primitive(null)), CodeGenHelper.Stm(CodeGenHelper.MethodCall(expression, "InitVars"))) }));
}
CodeExpression left = null;
foreach (DesignTable table2 in this.codeGenerator.TableHandler.Tables)
{
DataTable dataTable = table2.DataTable;
foreach (Constraint constraint in dataTable.Constraints)
{
if (constraint is ForeignKeyConstraint)
{
ForeignKeyConstraint constraint2 = (ForeignKeyConstraint)constraint;
CodeArrayCreateExpression expression3 = new CodeArrayCreateExpression(CodeGenHelper.GlobalType(typeof(DataColumn)), 0);
foreach (DataColumn column in constraint2.Columns)
{
expression3.Initializers.Add(CodeGenHelper.Property(CodeGenHelper.Field(CodeGenHelper.This(), this.codeGenerator.TableHandler.Tables[column.Table.TableName].GeneratorTableVarName), this.codeGenerator.TableHandler.Tables[column.Table.TableName].DesignColumns[column.ColumnName].GeneratorColumnPropNameInTable));
}
CodeArrayCreateExpression expression4 = new CodeArrayCreateExpression(CodeGenHelper.GlobalType(typeof(DataColumn)), 0);
foreach (DataColumn column2 in constraint2.RelatedColumns)
{
expression4.Initializers.Add(CodeGenHelper.Property(CodeGenHelper.Field(CodeGenHelper.This(), this.codeGenerator.TableHandler.Tables[column2.Table.TableName].GeneratorTableVarName), this.codeGenerator.TableHandler.Tables[column2.Table.TableName].DesignColumns[column2.ColumnName].GeneratorColumnPropNameInTable));
}
if (left == null)
{
initClassMethod.Statements.Add(CodeGenHelper.VariableDecl(CodeGenHelper.GlobalType(typeof(ForeignKeyConstraint)), "fkc"));
left = CodeGenHelper.Variable("fkc");
}
initClassMethod.Statements.Add(CodeGenHelper.Assign(left, CodeGenHelper.New(CodeGenHelper.GlobalType(typeof(ForeignKeyConstraint)), new CodeExpression[] { CodeGenHelper.Str(constraint2.ConstraintName), expression4, expression3 })));
initClassMethod.Statements.Add(CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.Field(CodeGenHelper.This(), this.codeGenerator.TableHandler.Tables[dataTable.TableName].GeneratorTableVarName), "Constraints"), "Add", left));
string field = constraint2.AcceptRejectRule.ToString();
string str2 = constraint2.DeleteRule.ToString();
string str3 = constraint2.UpdateRule.ToString();
initClassMethod.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(left, "AcceptRejectRule"), CodeGenHelper.Field(CodeGenHelper.GlobalTypeExpr(constraint2.AcceptRejectRule.GetType()), field)));
initClassMethod.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(left, "DeleteRule"), CodeGenHelper.Field(CodeGenHelper.GlobalTypeExpr(constraint2.DeleteRule.GetType()), str2)));
initClassMethod.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(left, "UpdateRule"), CodeGenHelper.Field(CodeGenHelper.GlobalTypeExpr(constraint2.UpdateRule.GetType()), str3)));
}
}
}
foreach (DesignRelation relation in this.codeGenerator.RelationHandler.Relations)
{
DataRelation dataRelation = relation.DataRelation;
if (dataRelation != null)
{
CodeArrayCreateExpression expression5 = new CodeArrayCreateExpression(CodeGenHelper.GlobalType(typeof(DataColumn)), 0);
string generatorTableVarName = relation.ParentDesignTable.GeneratorTableVarName;
foreach (DataColumn column3 in dataRelation.ParentColumns)
{
expression5.Initializers.Add(CodeGenHelper.Property(CodeGenHelper.Field(CodeGenHelper.This(), generatorTableVarName), this.codeGenerator.TableHandler.Tables[column3.Table.TableName].DesignColumns[column3.ColumnName].GeneratorColumnPropNameInTable));
}
CodeArrayCreateExpression expression6 = new CodeArrayCreateExpression(CodeGenHelper.GlobalType(typeof(DataColumn)), 0);
string str5 = relation.ChildDesignTable.GeneratorTableVarName;
foreach (DataColumn column4 in dataRelation.ChildColumns)
{
expression6.Initializers.Add(CodeGenHelper.Property(CodeGenHelper.Field(CodeGenHelper.This(), str5), this.codeGenerator.TableHandler.Tables[column4.Table.TableName].DesignColumns[column4.ColumnName].GeneratorColumnPropNameInTable));
}
CodeExpression expression7 = CodeGenHelper.Field(CodeGenHelper.This(), this.codeGenerator.RelationHandler.Relations[dataRelation.RelationName].GeneratorRelationVarName);
initClassMethod.Statements.Add(CodeGenHelper.Assign(expression7, CodeGenHelper.New(CodeGenHelper.GlobalType(typeof(DataRelation)), new CodeExpression[] { CodeGenHelper.Str(dataRelation.RelationName), expression5, expression6, CodeGenHelper.Primitive(false) })));
if (dataRelation.Nested)
{
initClassMethod.Statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(expression7, "Nested"), CodeGenHelper.Primitive(true)));
}
ExtendedPropertiesHandler.CodeGenerator = this.codeGenerator;
ExtendedPropertiesHandler.AddExtendedProperties(relation, expression7, initClassMethod.Statements, dataRelation.ExtendedProperties);
initClassMethod.Statements.Add(CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.This(), "Relations"), "Add", expression7));
initVarsMethod.Statements.Add(CodeGenHelper.Assign(expression7, CodeGenHelper.Indexer(CodeGenHelper.Property(CodeGenHelper.This(), "Relations"), CodeGenHelper.Str(dataRelation.RelationName))));
}
}
ExtendedPropertiesHandler.CodeGenerator = this.codeGenerator;
ExtendedPropertiesHandler.AddExtendedProperties(this.dataSource, CodeGenHelper.This(), initClassMethod.Statements, this.dataSet.ExtendedProperties);
}
