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);
}
internal DataComponentMethodGenerator(TypedDataSourceCodeGenerator codeGenerator, DesignTable designTable, bool generateHierarchicalUpdate)
{
this.generateHierarchicalUpdate = generateHierarchicalUpdate;
this.codeGenerator = codeGenerator;
this.designTable = designTable;
if (designTable.Connection != null)
{
this.providerFactory = ProviderManager.GetFactory(designTable.Connection.Provider);
}
}
internal void AddTypedRowEvents(CodeTypeDeclaration dataTableClass, string tableName)
{
DesignTable table = this.codeGenerator.TableHandler.Tables[tableName];
string generatorRowClassName = table.GeneratorRowClassName;
string generatorRowEvHandlerName = table.GeneratorRowEvHandlerName;
dataTableClass.Members.Add(CodeGenHelper.EventDecl(generatorRowEvHandlerName, table.GeneratorRowChangingName));
dataTableClass.Members.Add(CodeGenHelper.EventDecl(generatorRowEvHandlerName, table.GeneratorRowChangedName));
dataTableClass.Members.Add(CodeGenHelper.EventDecl(generatorRowEvHandlerName, table.GeneratorRowDeletingName));
dataTableClass.Members.Add(CodeGenHelper.EventDecl(generatorRowEvHandlerName, table.GeneratorRowDeletedName));
}
private bool TableContainsExpressions(DesignTable designTable)
{
foreach (DataColumn column in designTable.DataTable.Columns)
{
if (column.Expression.Length > 0)
{
return(true);
}
}
return(false);
}
internal void ProcessClassName(DesignTable table)
{
if (!StringUtil.EqualValue(table.DataAccessorName, table.UserDataComponentName, this.languageCaseInsensitive) || StringUtil.Empty(table.GeneratorDataComponentClassName))
{
table.GeneratorDataComponentClassName = this.validator.GenerateIdName(table.DataAccessorName);
}
else
{
table.GeneratorDataComponentClassName = this.validator.GenerateIdName(table.GeneratorDataComponentClassName);
}
}
protected override void OnRemove(int index, object value)
{
base.OnRemove(index, value);
DesignTable table = (DesignTable)value;
System.Data.DataSet dataSet = this.DataSet;
if (((dataSet != null) && (table.DataTable != null)) && dataSet.Tables.Contains(table.DataTable.TableName))
{
dataSet.Tables.Remove(table.DataTable);
}
table.Owner = null;
}
public DesignColumnCollection(DesignTable designTable) : base(designTable)
{
this.designTable = designTable;
if ((designTable != null) && (designTable.DataTable != null))
{
foreach (DataColumn column in designTable.DataTable.Columns)
{
this.Add(new DesignColumn(column));
}
}
this.table = designTable;
}
private void ProcessMemberNames(DesignTable designTable)
{
this.ProcessClassName(designTable);
if (!this.GlobalSources && (designTable.MainSource != null))
{
this.ProcessSourceName((DbSource)designTable.MainSource);
}
if (designTable.Sources != null)
{
foreach (Source source in designTable.Sources)
{
this.ProcessSourceName((DbSource)source);
}
}
}
public void SetDesignTableContent(string designTableContent)
{
DesignDataSource source = new DesignDataSource();
StringReader textReader = new StringReader(designTableContent);
source.ReadXmlSchema(textReader, null);
if ((source.DesignTables == null) || (source.DesignTables.Count != 1))
{
throw new InternalException("Unexpected number of sources in deserialized DataSource.");
}
IEnumerator enumerator = source.DesignTables.GetEnumerator();
enumerator.MoveNext();
this.designTable = (DesignTable)enumerator.Current;
}
public frmShowCars(string st)
{
str = st;
InitializeComponent();
ColorsTable curentColor = new ColorsTable();
Suport.FillCombox(cmbColor, curentColor.GetTable(), "nameColor", "coudeColor");
//Suport.FillCombox(cmbPlace , curentp .FillConbo(), "numParking", "coudParking");
DesignTable curentd = new DesignTable();
Suport.FillCombox(cmbDesign, curentd.GetTable(), "nameDesign", "coudDesign");
BranchTable curentb = new BranchTable();
Suport.FillCombox(cmbBranch, curentb.GetTable(), "branchName", "branchCoude");
if (st == "add")
{
lblAddCar.Visible = true;
lblMessage.Visible = false;
btnAdd.Visible = true;
label9.Visible = false;
txtNumForSerch.Visible = false;
btnSearch.Visible = false;
}
if (st == "update")
{
lblAddCar.Visible = false;
lblMessage.Visible = true;
btnUpdate.Visible = true;
pcbPicture.Visible = true;
pcbPicture.Visible = true;
}
if (st == "del")
{
lblAddCar.Visible = false;
lblMessage.Visible = true;
btnDel.Visible = true;
pcbPicture.Visible = true;
}
}
private void ClearChanged()
{
Schema.Changed = false;
Schema.Tables.ForEach(t =>
{
t.Changed = false;
var last = t.Columns.Last();
if (!last.IsEmpty())
{
t.Columns.Add(new DesignColumn {
});
}
});
SelectedTable = null;
}
private DesignRelation FindCorrespondingDesignRelation(DesignTable designTable, DataRelation relation)
{
DesignDataSource owner = designTable.Owner;
if (owner == null)
{
throw new InternalException("Unable to find DataSource for table.");
}
foreach (DesignRelation relation2 in owner.DesignRelations)
{
if (((relation2.DataRelation != null) && StringUtil.EqualValue(relation2.DataRelation.ChildTable.TableName, relation.ChildTable.TableName)) && (StringUtil.EqualValue(relation2.DataRelation.ParentTable.TableName, relation.ParentTable.TableName) && StringUtil.EqualValue(relation2.Name, relation.RelationName)))
{
return(relation2);
}
}
return(null);
}
//public void LoadSchema()
//{
//}
public void NewSchema()
{
Schema = new DesignSchema {
Name = "New Schema", Version = "1.0", DataContextName = Parameters.DataService, Namespace = Parameters.Namespace, Changed = true, IsNew = true
};
SchemaMigrations = new DesignSchemaMigrations();
var nm = new StoreMigration {
Version = DesignSchemaMigrations.InitialVersion, Created = DateTime.UtcNow, VersionKey = Guid.NewGuid()
};
//SchemaMigrations.Migrations.Add(new DesignMigration { StatusText = "Empty", VersionText = "Initial 1.0" });
SchemaMigrations.Migrations.Add(new DesignMigration(nm));
SelectedTable = null;
ClearLog();
UpdateLog(DesignOperation.CreateSchema);
UpdateDiagramTables();
}
internal ArrayList GetRelatedRelations(ICollection tableList)
{
ArrayList list = new ArrayList();
foreach (DesignRelation relation in this.DesignRelations)
{
DesignTable parentDesignTable = relation.ParentDesignTable;
DesignTable childDesignTable = relation.ChildDesignTable;
foreach (object obj2 in tableList)
{
if ((parentDesignTable == obj2) || (childDesignTable == obj2))
{
list.Add(relation);
break;
}
}
}
return(list);
}
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);
}
protected override void OnInsert(int index, object value)
{
base.OnInsert(index, value);
DesignTable table = (DesignTable)value;
if ((table.Name == null) || (table.Name.Length == 0))
{
table.Name = this.CreateUniqueName(table);
}
this.NameService.ValidateUniqueName(this, table.Name);
if ((this.dataSource == null) || (table.Owner != this.dataSource))
{
if ((this.dataSource != null) && (table.Owner != null))
{
throw new InternalException("This table belongs to another DataSource already", 0x4e22);
}
System.Data.DataSet dataSet = this.DataSet;
if ((dataSet != null) && !dataSet.Tables.Contains(table.DataTable.TableName))
{
dataSet.Tables.Add(table.DataTable);
}
table.Owner = this.dataSource;
}
}
internal void GenerateDataSource(DesignDataSource dtDataSource, CodeCompileUnit codeCompileUnit, CodeNamespace mainNamespace, string dataSetNamespace, System.Data.Design.TypedDataSetGenerator.GenerateOption generateOption)
{
this.designDataSource = dtDataSource;
this.generateOption = generateOption;
this.dataSetNamespace = dataSetNamespace;
bool generateHierarchicalUpdate = ((generateOption & System.Data.Design.TypedDataSetGenerator.GenerateOption.HierarchicalUpdate) == System.Data.Design.TypedDataSetGenerator.GenerateOption.HierarchicalUpdate) && dtDataSource.EnableTableAdapterManager;
this.AddUserData(codeCompileUnit);
CodeTypeDeclaration declaration = this.CreateDataSourceDeclaration(dtDataSource);
mainNamespace.Types.Add(declaration);
bool flag2 = CodeGenHelper.SupportsMultipleNamespaces(this.codeProvider);
CodeNamespace namespace2 = null;
if (!this.GenerateSingleNamespace && flag2)
{
string name = this.CreateAdaptersNamespace(dtDataSource.GeneratorDataSetName);
if (!StringUtil.Empty(mainNamespace.Name))
{
name = mainNamespace.Name + "." + name;
}
namespace2 = new CodeNamespace(name);
}
DataComponentGenerator generator = new DataComponentGenerator(this);
bool flag3 = false;
foreach (DesignTable table in dtDataSource.DesignTables)
{
if (table.TableType == TableType.RadTable)
{
flag3 = true;
table.PropertyCache = new DesignTable.CodeGenPropertyCache(table);
CodeTypeDeclaration declaration2 = generator.GenerateDataComponent(table, false, generateHierarchicalUpdate);
if (this.GenerateSingleNamespace)
{
mainNamespace.Types.Add(declaration2);
}
else if (flag2)
{
namespace2.Types.Add(declaration2);
}
else
{
declaration2.Name = declaration.Name + declaration2.Name;
mainNamespace.Types.Add(declaration2);
}
}
}
generateHierarchicalUpdate = generateHierarchicalUpdate && flag3;
if ((dtDataSource.Sources != null) && (dtDataSource.Sources.Count > 0))
{
DesignTable designTable = new DesignTable {
TableType = TableType.RadTable,
MainSource = null,
GeneratorDataComponentClassName = dtDataSource.GeneratorFunctionsComponentClassName
};
foreach (Source source in dtDataSource.Sources)
{
designTable.Sources.Add(source);
}
CodeTypeDeclaration declaration3 = generator.GenerateDataComponent(designTable, true, generateHierarchicalUpdate);
if (this.GenerateSingleNamespace)
{
mainNamespace.Types.Add(declaration3);
}
else if (flag2)
{
namespace2.Types.Add(declaration3);
}
else
{
declaration3.Name = declaration.Name + declaration3.Name;
mainNamespace.Types.Add(declaration3);
}
}
if ((namespace2 != null) && (namespace2.Types.Count > 0))
{
codeCompileUnit.Namespaces.Add(namespace2);
}
if (generateHierarchicalUpdate)
{
CodeTypeDeclaration declaration4 = new TableAdapterManagerGenerator(this).GenerateAdapterManager(this.designDataSource, declaration);
if (this.GenerateSingleNamespace)
{
mainNamespace.Types.Add(declaration4);
}
else if (flag2)
{
namespace2.Types.Add(declaration4);
}
else
{
declaration4.Name = declaration.Name + declaration4.Name;
mainNamespace.Types.Add(declaration4);
}
}
}
internal void ProcessEventNames(DesignTable designTable)
{
bool flag = false;
bool flag2 = !StringUtil.EqualValue(designTable.Name, designTable.UserTableName, this.languageCaseInsensitive);
string name = designTable.GeneratorRowClassName + "Changing";
if (flag2 || StringUtil.Empty(designTable.GeneratorRowChangingName))
{
designTable.GeneratorRowChangingName = this.validator.GenerateIdName(name);
}
else
{
designTable.GeneratorRowChangingName = this.validator.GenerateIdName(designTable.GeneratorRowChangingName);
}
if (!StringUtil.EqualValue(this.validator.GenerateIdName(name), designTable.GeneratorRowChangingName))
{
designTable.NamingPropertyNames.Add(DesignTable.EXTPROPNAME_GENERATOR_ROWCHANGINGNAME);
flag = true;
}
string str2 = designTable.GeneratorRowClassName + "Changed";
if (flag2 || StringUtil.Empty(designTable.GeneratorRowChangedName))
{
designTable.GeneratorRowChangedName = this.validator.GenerateIdName(str2);
}
else
{
designTable.GeneratorRowChangedName = this.validator.GenerateIdName(designTable.GeneratorRowChangedName);
}
if (!StringUtil.EqualValue(this.validator.GenerateIdName(str2), designTable.GeneratorRowChangedName))
{
designTable.NamingPropertyNames.Add(DesignTable.EXTPROPNAME_GENERATOR_ROWCHANGEDNAME);
flag = true;
}
string str3 = designTable.GeneratorRowClassName + "Deleting";
if (flag2 || StringUtil.Empty(designTable.GeneratorRowDeletingName))
{
designTable.GeneratorRowDeletingName = this.validator.GenerateIdName(str3);
}
else
{
designTable.GeneratorRowDeletingName = this.validator.GenerateIdName(designTable.GeneratorRowDeletingName);
}
if (!StringUtil.EqualValue(this.validator.GenerateIdName(str3), designTable.GeneratorRowDeletingName))
{
designTable.NamingPropertyNames.Add(DesignTable.EXTPROPNAME_GENERATOR_ROWDELETINGNAME);
flag = true;
}
string str4 = designTable.GeneratorRowClassName + "Deleted";
if (flag2 || StringUtil.Empty(designTable.GeneratorRowDeletedName))
{
designTable.GeneratorRowDeletedName = this.validator.GenerateIdName(str4);
}
else
{
designTable.GeneratorRowDeletedName = this.validator.GenerateIdName(designTable.GeneratorRowDeletedName);
}
if (!StringUtil.EqualValue(this.validator.GenerateIdName(str4), designTable.GeneratorRowDeletedName))
{
designTable.NamingPropertyNames.Add(DesignTable.EXTPROPNAME_GENERATOR_ROWDELETEDNAME);
flag = true;
}
if (flag && !designTable.NamingPropertyNames.Contains(DesignTable.EXTPROPNAME_USER_TABLENAME))
{
designTable.NamingPropertyNames.Add(DesignTable.EXTPROPNAME_USER_TABLENAME);
}
}
/// <summary>
/// Keeps log that allows to record migrations and undo/redo
/// </summary>
/// <param name="operation"></param>
/// <param name="table"></param>
/// <param name="column"></param>
public void UpdateLog(DesignOperation op, DesignTable table = null, DesignColumn column = null, string newName = null)
{
if (SchemaMigrations.Migrations.Any())
{
var last = SchemaMigrations.Migrations.Last();
last.Migration.Status = MigrationStatus.Editing;
}
if (table?.IsNew == false && _changeOperations.Contains(op))
{
_designRecords.Add(
new DesignLogRecord
{
Operation = DesignOperation.ExistingTableChanged,
TableName = table?.Name,
TableId = table?.Id,
ColumnName = column?.Name,
ColumnId = column?.Id,
});
}
var operation = op;
string old = null;
string newValue = null;
switch (operation)
{
case DesignOperation.SetSchemaName:
newValue = newName;
old = Schema.Name;
break;
case DesignOperation.SetTableName:
newValue = table.Name;
old = FindClone <DesignTable>(table.Id)?.Name;
break;
case DesignOperation.SetColumnName:
newValue = column.Name;
old = FindClone <DesignColumn>(column.Id)?.Name;
break;
case DesignOperation.SetColumnNullable:
newValue = column.Nullable.ToString();
old = FindClone <DesignColumn>(column.Id)?.Nullable.ToString();
break;
case DesignOperation.SetColumnType:
newValue = column.Type;
old = FindClone <DesignColumn>(column.Id)?.Type;
break;
case DesignOperation.SetColumnReference:
newValue = column.Reference;
old = FindClone <DesignColumn>(column.Id)?.Reference;
break;
}
if (op == DesignOperation.SetColumnName)
{
if (string.IsNullOrWhiteSpace(old))
{
operation = DesignOperation.AddColumn;
}
else
{
operation = DesignOperation.SetColumnName;
}
}
else if ((op == DesignOperation.SetColumnNullable || op == DesignOperation.SetColumnType || op == DesignOperation.SetColumnReference) &&
FindClone <DesignColumn>(column.Id) == null)
{
operation = DesignOperation.AddColumn;
}
_designRecords.Add(
new DesignLogRecord
{
Operation = operation, TableName = table?.Name, TableId = table?.Id, ColumnName = column?.Name, ColumnId = column?.Id,
OldValue = old, NewValue = newValue, OldColumn = column?.GetCopy() as DesignColumn
});
// save clones
if (table != null)
{
_objectClones[table.Id] = table.GetCopy(table.Id);
}
if (column != null)
{
_objectClones[column.Id] = column.GetCopy(column.Id);
}
}
public void Remove(DesignTable table)
{
base.List.Remove(table);
}
public void SelectTable(DesignTable table)
{
SelectedTable = table;
_tableController.Load(Schema, SelectedTable);
_tableController.Update();
}
public int IndexOf(DesignTable table)
{
return(base.List.IndexOf(table));
}
public bool Contains(DesignTable table)
{
return(base.List.Contains(table));
}
public void Add(DesignTable designTable)
{
base.List.Add(designTable);
}
internal QueryHandler(TypedDataSourceCodeGenerator codeGenerator, DesignTable designTable)
{
this.codeGenerator = codeGenerator;
this.designTable = designTable;
this.languageSupportsNullables = this.codeGenerator.CodeProvider.Supports(GeneratorSupport.GenericTypeReference);
}
internal void ProcessTableRelatedNames(DesignTable table)
{
bool usesAnnotations = false;
bool flag2 = false;
bool flag3 = !StringUtil.EqualValue(table.Name, table.UserTableName, this.languageCaseInsensitive);
string name = this.TablePropertyName(table.DataTable, out usesAnnotations);
string str2 = this.PlainTablePropertyName(table.DataTable, out usesAnnotations);
if (usesAnnotations)
{
table.GeneratorTablePropName = str2;
}
else
{
if (flag3 || StringUtil.Empty(table.GeneratorTablePropName))
{
table.GeneratorTablePropName = this.validator.GenerateIdName(name);
}
else
{
table.GeneratorTablePropName = this.validator.GenerateIdName(table.GeneratorTablePropName);
}
if (!StringUtil.EqualValue(this.validator.GenerateIdName(name), table.GeneratorTablePropName))
{
table.NamingPropertyNames.Add(DesignTable.EXTPROPNAME_GENERATOR_TABLEPROPNAME);
flag2 = true;
}
}
string str3 = this.TableVariableName(table.DataTable, out usesAnnotations);
string str4 = this.PlainTableVariableName(table.DataTable, out usesAnnotations);
if (usesAnnotations)
{
table.GeneratorTableVarName = str4;
}
else
{
if (flag3 || StringUtil.Empty(table.GeneratorTableVarName))
{
table.GeneratorTableVarName = this.validator.GenerateIdName(str3);
}
else
{
table.GeneratorTableVarName = this.validator.GenerateIdName(table.GeneratorTableVarName);
}
if (!StringUtil.EqualValue(this.validator.GenerateIdName(str3), table.GeneratorTableVarName))
{
table.NamingPropertyNames.Add(DesignTable.EXTPROPNAME_GENERATOR_TABLEVARNAME);
flag2 = true;
}
}
string str5 = this.TableClassName(table.DataTable, out usesAnnotations);
string str6 = this.PlainTableClassName(table.DataTable, out usesAnnotations);
if (usesAnnotations)
{
table.GeneratorTableClassName = str6;
}
else
{
if (flag3 || StringUtil.Empty(table.GeneratorTableClassName))
{
table.GeneratorTableClassName = this.validator.GenerateIdName(str5);
}
else
{
table.GeneratorTableClassName = this.validator.GenerateIdName(table.GeneratorTableClassName);
}
if (!StringUtil.EqualValue(this.validator.GenerateIdName(str5), table.GeneratorTableClassName))
{
table.NamingPropertyNames.Add(DesignTable.EXTPROPNAME_GENERATOR_TABLECLASSNAME);
flag2 = true;
}
}
string str7 = this.RowClassName(table.DataTable, out usesAnnotations);
string str8 = this.PlainRowClassName(table.DataTable, out usesAnnotations);
if (usesAnnotations)
{
table.GeneratorRowClassName = str8;
}
else
{
if (flag3 || StringUtil.Empty(table.GeneratorRowClassName))
{
table.GeneratorRowClassName = this.validator.GenerateIdName(str7);
}
else
{
table.GeneratorRowClassName = this.validator.GenerateIdName(table.GeneratorRowClassName);
}
if (!StringUtil.EqualValue(this.validator.GenerateIdName(str7), table.GeneratorRowClassName))
{
table.NamingPropertyNames.Add(DesignTable.EXTPROPNAME_GENERATOR_ROWCLASSNAME);
flag2 = true;
}
}
string str9 = this.RowEventHandlerName(table.DataTable, out usesAnnotations);
string str10 = this.PlainRowEventHandlerName(table.DataTable, out usesAnnotations);
if (usesAnnotations)
{
table.GeneratorRowEvHandlerName = str10;
}
else
{
if (flag3 || StringUtil.Empty(table.GeneratorRowEvHandlerName))
{
table.GeneratorRowEvHandlerName = this.validator.GenerateIdName(str9);
}
else
{
table.GeneratorRowEvHandlerName = this.validator.GenerateIdName(table.GeneratorRowEvHandlerName);
}
if (!StringUtil.EqualValue(this.validator.GenerateIdName(str9), table.GeneratorRowEvHandlerName))
{
table.NamingPropertyNames.Add(DesignTable.EXTPROPNAME_GENERATOR_ROWEVHANDLERNAME);
flag2 = true;
}
}
string str11 = this.RowEventArgClassName(table.DataTable, out usesAnnotations);
string str12 = this.PlainRowEventArgClassName(table.DataTable, out usesAnnotations);
if (usesAnnotations)
{
table.GeneratorRowEvArgName = str12;
}
else
{
if (flag3 || StringUtil.Empty(table.GeneratorRowEvArgName))
{
table.GeneratorRowEvArgName = this.validator.GenerateIdName(str11);
}
else
{
table.GeneratorRowEvArgName = this.validator.GenerateIdName(table.GeneratorRowEvArgName);
}
if (!StringUtil.EqualValue(this.validator.GenerateIdName(str11), table.GeneratorRowEvArgName))
{
table.NamingPropertyNames.Add(DesignTable.EXTPROPNAME_GENERATOR_ROWEVARGNAME);
flag2 = true;
}
}
if (flag2)
{
table.NamingPropertyNames.Add(DesignTable.EXTPROPNAME_USER_TABLENAME);
}
}
internal TableMethodGenerator(TypedDataSourceCodeGenerator codeGenerator, DesignTable designTable)
{
this.codeGenerator = codeGenerator;
this.designTable = designTable;
}
