internal object GetMemberIndex(MetaDataMember member)
{
MetaDataTable table = tablesHeap.GetTable(member.Table);
uint index = (uint)(member.metadatatoken - ((uint)table.Type << 24));
return(ProcessIndex(table, index));
}
/// <summary>
/// 使用OracleBulkCopy方式向表中批量添加数据。
/// </summary>
/// <param name="entities">记录集合</param>
/// <param name="columnNames">目标表列名集合</param>
/// <returns>0表示成功，其他失败</returns>
protected virtual int InsertByBulkCopy(List <T> entities, params string[] columnNames)
{
if (entities == null || entities.Count == 0)
{
throw new ArgumentNullException("entites");
}
MetaDataTable metaDataTable = new MetaDataTable(typeof(T), this._tableName);
DataTable dataTable = this.GetDataTable(entities, metaDataTable, columnNames);
using (OracleBulkCopy bulkCopy = new OracleBulkCopy(this._connectionString))
{
bulkCopy.DestinationTableName = this._tableName;
bulkCopy.BatchSize = dataTable.Rows.Count;
this.SetColumnMappings(bulkCopy.ColumnMappings, metaDataTable, columnNames);
try
{
bulkCopy.WriteToServer(dataTable);
}
catch (Exception ex)
{
string message = string.Format("[SQL]:{0},[Exception]:{1}", "BulkCopy", ex.ToString());
throw new ApplicationException(message);
}
}
return(0);
}
public void should_convert_data_table_sheet1_with_metadata()
{
var importer = new Presentation.Services.Importer.Importer(_dataRepositoryMapper, _columnInfos, _importerTask, _dialogCreator);
var metaData = new MetaDataTable();
_importDataTable.MetaData = metaData;
metaData.Columns.Add(new MetaDataColumn
{
DataType = typeof(string),
ColumnName = "Column1",
DisplayName = "DisplayColumn1",
Description = "Text for Column1",
Required = true,
ListOfValues = new Dictionary <string, string> {
{ "A", "A" }, { "B", "B" }
},
IsListOfValuesFixed = true,
DefaultValue = "A"
});
var tables = importer.ImportDataTables(_importDataTable, _excelFile, _sheetNames[0], _cms);
tables[0].MetaData.Rows.Add((MetaDataRow)tables[0].MetaData.NewRow());
bool errorNaN;
var dataRepositories = sut.ConvertImportDataTableList(tables, _columnInfos, out errorNaN);
errorNaN.ShouldBeFalse();
dataRepositories.Count.ShouldBeEqualTo(2);
dataRepositories[0].ExtendedProperties.Contains(metaData.Columns.ItemByIndex(0).ColumnName).ShouldBeTrue();
dataRepositories[0].ExtendedProperties[metaData.Columns.ItemByIndex(0).ColumnName].ValueAsObject.ShouldBeEqualTo(metaData.Columns.ItemByIndex(0).DefaultValue);
}
/// <summary>
/// 执行一条查询语句，并以实体对象集合形式返回查询结果集。
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="sqlCmd">SQL命令</param>
/// <param name="parameters">SQL参数对应值的集合,如果SQL语句字符串中含有参数标记,则必须设置该数组的值</param>
/// <param name="commandType">CommandType</param>
/// <param name="drToEntityAction">读出DataReader数据到DTO</param>
/// <param name="columnNames">该实体对象中对应的数据库表的列名</param>
/// <returns>实体对象集合</returns>
protected virtual List <TEntity> GetEntities <TEntity>(string sqlCmd, OleDbParameter[] parameters, CommandType commandType,
Func <OleDbDataReader, MetaDataTable, string[], TEntity> drToEntityAction, params string[] columnNames)
{
List <TEntity> entities = new List <TEntity>();
var metaDataTable = new MetaDataTable(typeof(TEntity), this._tableName);
using (OleDbDataReader dr = OleDbHelper.ExecuteReader(this._connectionString, commandType, sqlCmd, parameters))
{
try
{
do
{
while (dr.Read())
{
entities.Add(drToEntityAction(dr, metaDataTable, columnNames));
}
} while (dr.NextResult());
}
catch (Exception ex)
{
string message = string.Format("[SQL]:{0},[Exception]:{1}", sqlCmd, ex.ToString());
System.Diagnostics.EventLog.WriteEntry("LightFramework.Data.OleDb", message);
}
}
return(entities);
}
public static IEnumerable <string> AllTableSheetNames(XlsxPivotReader book)
{
var pivotWorkSheetNames = from n in book.WorksheetNames
let name = n.ToLowerInvariant()
where
name.StartsWith(Prefix) &&
!PivotSheets.Equals(name) &&
!name.StartsWith(PivotData)
select n;
var pivotSheetNames = from sheetName in pivotWorkSheetNames
select book[sheetName].Entities <SheetNaming>();
var pivotTableNames = from sheetNames in pivotSheetNames
from sheetName in sheetNames
select sheetName.Name;
var allNames = (from n in pivotTableNames.Union(MetaDataTable.PivotTableSheets(book.MetaDataTables))
where !string.IsNullOrEmpty(n)
select n).Distinct(System.StringComparer.OrdinalIgnoreCase).ToList();
if (allNames.Count > 0)
{
return(allNames);
}
return(from n in book.WorksheetNames
where !n.ToLowerInvariant().StartsWith(SheetNaming.Prefix)
select n);
}
private bool setMetaData(MetaDataTable target, MetaDataTable source)
{
if (target == null)
{
return(true);
}
MetaDataRow newRow = (MetaDataRow)target.NewRow();
for (var i = 0; i < newRow.ItemArray.Length; i++)
{
if (!source.Columns.ItemByIndex(i).IsColumnUsedForGrouping)
{
newRow[i] = source.Rows.ItemByIndex(0)[i];
}
}
if (target.Rows.Count == 0)
{
target.Rows.Add(newRow);
}
else
{
target.Rows.ItemByIndex(0).ItemArray = newRow.ItemArray;
}
target.AcceptChanges();
return(false);
}
private void tablesTree_AfterSelect(object sender, TreeViewEventArgs e)
{
dataGridView.Rows.Clear();
if (e.Node.Tag is MetaDataTable)
{
MetaDataTable table = e.Node.Tag as MetaDataTable;
if (e.Node.Nodes.Count == 1 && e.Node.Nodes[0].Text == "Loading...")
{
e.Node.Nodes.Clear();
TreeNode[] subNodes = new TreeNode[table.Members.Count];
for (int i = 0; i < subNodes.Length; i++)
{
subNodes[i] = CreateTreeNode(table.Members[i]);
}
tablesTree.BeginUpdate();
e.Node.Nodes.AddRange(subNodes);
tablesTree.EndUpdate();
}
}
else if (e.Node.Tag is MetaDataMember)
{
currentMember = (MetaDataMember)e.Node.Tag;
propertyGrid.SelectedObject = currentMember;
SetMetaDataRow(currentMember.MetaDataRow);
}
}
/// <summary>
/// 使用SQLServer2008及以上版本表值参数方式向表中批量添加数据,需要先在数据库创建与目标表结构相同的表。
/// 且表名必须为tvps。
/// </summary>
/// <param name="entities">记录集合</param>
/// <param name="columnNames">目标表列名集合</param>
/// <returns>影响行数</returns>
protected virtual int InsertByTableValue(List <T> entities, params string[] columnNames)
{
if (entities == null || entities.Count == 0)
{
throw new ArgumentNullException("entites");
}
MetaDataTable metaDataTable = new MetaDataTable(typeof(T), this._tableName);
using (SqlConnection conn = new SqlConnection(this._connectionString))
{
string sql = string.Format("insert into {0} select * from @tableName;", this._tableName);
SqlCommand cmd = new SqlCommand(sql, conn);
SqlParameter param = cmd.Parameters.AddWithValue("@tableName", this.GetDataTable(entities, metaDataTable, columnNames));
param.SqlDbType = SqlDbType.Structured;
param.TypeName = "dbo.tvps";
try
{
conn.Open();
return(cmd.ExecuteNonQuery());
}
catch (Exception ex)
{
string message = string.Format("[SQL]:{0},[Exception]:{1}", "TableValueParameter", ex.ToString());
throw new ApplicationException(message);
}
}
}
internal void ReadTableHeaders()
{
SetupCodedIndexes();
for (int i = 0; i < 45; i++)
{
if (tablesHeap.HasTable((MetaDataTableType)i))
{
long headerOffset = reader.BaseStream.Position + tablesHeap.StreamOffset;
MetaDataTable table = CreateTable((MetaDataTableType)i, reader.ReadInt32(), headerOffset);
tablesHeap.tables[i] = table;
}
}
uint tableOffset = (uint)(tablesHeap.StreamOffset + Marshal.SizeOf(typeof(Structures.METADATA_TABLE_HEADER)) + (tablesHeap.tablecount) * 4);
foreach (MetaDataTable table in tablesHeap.tables)
{
if (table != null)
{
table.TableOffset = tableOffset;
tableOffset += (uint)table.PhysicalSize;
}
}
}
/// <summary>
/// Get meta data from a SQL statement
/// </summary>
/// <param name="connectionString">Connection string to use</param>
/// <param name="entityName">Name of the entity class</param>
/// /// <param name="cmd">Current command to get meta data for</param>
/// <param name="nameOfPrimaryKeyField">Name of the primary key field. Default: null</param>
public override void GetMetaData(string connectionString, string entityName, DbCommand cmd, string nameOfPrimaryKeyField = null)
{
if (string.IsNullOrEmpty(nameOfPrimaryKeyField))
{
nameOfPrimaryKeyField = "CustomerId";
}
var table = new MetaDataTable
{
Name = entityName,
Sql = "SELECT * FROM Customer"
};
var f = new MetaDataField
{
Name = nameOfPrimaryKeyField,
DatabaseType = typeof(int)
};
f.SourceDataType = f.DatabaseType.ToString();
table.Fields.Add(f);
f = new MetaDataField
{
Name = "Customer",
DatabaseType = typeof(string)
};
f.SourceDataType = f.DatabaseType.ToString();
table.Fields.Add(f);
Table = table;
}
private void ReorderRange <TParent, TMember>(Workspace workspace, MetaDataTableType parentTable, MetaDataTableType memberTable, int memberListIndex, Func <TParent, TMember[]> getMembersFunc)
where TParent : MetaDataMember
where TMember : MetaDataMember
{
if (workspace.Members.ContainsKey(parentTable) && workspace.Members.ContainsKey(memberTable))
{
MetaDataMemberInfo[] newRange = new MetaDataMemberInfo[workspace.Members[memberTable].Length];
TParent[] parentMembers = workspace.GetMembers <TParent>(parentTable);
MetaDataTable targetTable = workspace.Members[memberTable][0].Instance.Table;
uint currentIndex = 0;
for (int i = 0; i < parentMembers.Length; i++)
{
TMember[] members = getMembersFunc(parentMembers[i]);
if (members.Length > 0)
{
int startIndex = workspace.GetIndexOfMember(members[0]);
int endIndex = workspace.GetIndexOfMember(members[members.Length - 1]);
Array.Copy(workspace.Members[memberTable], startIndex, newRange, currentIndex, endIndex - startIndex + 1);
}
parentMembers[i].MetaDataRow.Parts[memberListIndex] = ConvertToIndex(targetTable, currentIndex + 1);
currentIndex += (uint)members.Length;
}
workspace.Members[memberTable] = newRange;
}
}
private void ExtractInitialData()
{
FileInfo fi = new FileInfo(FileName);
string fullName = fi.FullName;
string name = fi.Name;
string directoryName = fi.DirectoryName;
bool isReadOnly = fi.IsReadOnly;
string readOnly;
if (isReadOnly == true)
{
readOnly = "True";
}
else
{
readOnly = "False";
}
string utcCreationTime = fi.CreationTimeUtc.ToString("yyyy-MM-dd HH:mm:ss");
string extension = fi.Extension;
string utcLastAccessed = fi.LastAccessTimeUtc.ToString("yyyy-MM-dd HH:mm:ss");
string utcLastWrite = fi.LastWriteTimeUtc.ToString("yyyy-MM-dd HH:mm:ss");
string FileLength = fi.Length.ToString("N0");
MetaDataTable.Rows.Add("BasicData", "Full Name", fullName);
MetaDataTable.Rows.Add("BasicData", "Name", name);
MetaDataTable.Rows.Add("BasicData", "Directory Name", directoryName);
MetaDataTable.Rows.Add("BasicData", "Is Read Only", readOnly);
MetaDataTable.Rows.Add("BasicData", "UTC Creation Time", utcCreationTime);
MetaDataTable.Rows.Add("BasicData", "UTC Last Access Time", utcLastAccessed);
MetaDataTable.Rows.Add("BasicData", "UTC Last Write Time", utcLastWrite);
MetaDataTable.Rows.Add("BasicData", "File Extension", extension);
MetaDataTable.Rows.Add("BasicData", "File Length Bytes", FileLength);
MetaDataTable.AcceptChanges();
}
public List <MetaDataTable> GetMetaTables()
{
try
{
List <MetaDataTable> tables = new List <MetaDataTable>();
navConnection.Open();
using (SqlCommand command = new SqlCommand("select top 20 [TABLE_NAME], [TABLE_TYPE] from INFORMATION_SCHEMA.TABLES", navConnection))
{
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
MetaDataTable tmp = new MetaDataTable
{
Table_Name = reader.GetValue(0) as string,
Table_Type = reader.GetValue(1) as string
};
tables.Add(tmp);
}
}
}
navConnection.Close();
return(tables);
}
catch (Exception e)
{
throw ExceptionHandler.HandleEFException(e);
}
finally
{
navConnection.Close();
}
}
/// <summary>
/// 执行一条查询语句，并以实体对象集合形式返回查询结果集。
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="sqlCmd">SQL命令</param>
/// <param name="parameters">SQL参数对应值的集合,如果SQL语句字符串中含有参数标记,则必须设置该数组的值</param>
/// <param name="commandType">CommandType</param>
/// <param name="drToEntityAction">读出DataReader数据到DTO</param>
/// <param name="columnNames">该实体对象中对应的数据库表的列名</param>
/// <returns>实体对象集合</returns>
protected virtual List <TEntity> GetEntities <TEntity>(string sqlCmd, SqlParameter[] parameters, CommandType commandType,
Func <SqlDataReader, MetaDataTable, string[], TEntity> drToEntityAction, params string[] columnNames)
{
List <TEntity> entities = new List <TEntity>();
var metaDataTable = new MetaDataTable(typeof(TEntity), this._tableName);
using (SqlDataReader dr = SqlHelper.ExecuteReader(this._connectionString, commandType, sqlCmd, parameters))
{
try
{
do
{
while (dr.Read())
{
entities.Add(drToEntityAction(dr, metaDataTable, columnNames));
}
} while (dr.NextResult());
}
catch (SqlException ex)
{
throw new ApplicationException(string.Format("[SQL]:{0},[Exception]:{1}", sqlCmd, ex.ToString()));
}
}
return(entities);
}
/// <summary>
/// This method converts a list of meta data categories to a meta data table.
/// </summary>
/// <param name="metaDataCategories">List of meta data categories.</param>
/// <returns>A meta data table.</returns>
private static MetaDataTable convertToMetaDataTable(IEnumerable <MetaDataCategory> metaDataCategories)
{
var retVal = new MetaDataTable();
foreach (var metaDataCategory in metaDataCategories)
{
var column = new MetaDataColumn
{
ColumnName = metaDataCategory.Name,
DisplayName = metaDataCategory.DisplayName,
Description = metaDataCategory.Description,
ListOfValues = metaDataCategory.ListOfValues,
ListOfImages = metaDataCategory.ListOfImages,
IsListOfValuesFixed = metaDataCategory.IsListOfValuesFixed,
MinValue = metaDataCategory.MinValue,
MinValueAllowed = metaDataCategory.MinValueAllowed,
MaxValue = metaDataCategory.MaxValue,
MaxValueAllowed = metaDataCategory.MaxValueAllowed,
Required = metaDataCategory.IsMandatory,
DataType = metaDataCategory.MetaDataType,
DefaultValue = metaDataCategory.DefaultValue
};
if (metaDataCategory.MetaDataType == typeof(string))
{
column.MaxLength = metaDataCategory.MaxLength;
}
retVal.Columns.Add(column);
}
return(retVal);
}
private ValueType ConvertToIndex(MetaDataTable table, uint index)
{
if (table.IsLarge(0))
{
return(index);
}
return((ushort)index);
}
private NumberIdSeq DataReaderToNumberIdSeq(MySqlDataReader dr, MetaDataTable metaDataTable, params string[] columnNames)
{
if (dr == null)
{
throw new ArgumentNullException("dr", "未将对象引用到实例");
}
return(EntityMapper.GetEntity <NumberIdSeq>(dr, new NumberIdSeq(), this._tableName));
}
private DimensionNumberType DataReaderToNumberTypeDim(SqlDataReader dr, MetaDataTable metaDataTable, params string[] columnNames)
{
if (dr == null)
{
throw new ArgumentNullException("dr", "未将对象引用到实例");
}
return(EntityMapper.GetEntity <DimensionNumberType>(dr, new DimensionNumberType(), this._tableName));
}
protected override DwNumber DataReaderToEntity(MySqlDataReader dr, MetaDataTable metaDataTable, params string[] columnNames)
{
if (dr == null)
{
throw new ArgumentNullException("dr", "未将对象引用到实例");
}
return(EntityMapper.GetEntity <DwNumber>(dr, new DwNumber(), this._tableName));
}
/// <summary>
/// 将DataReader的属性值转化为实体类的属性值，返回实体类
/// </summary>
/// <param name="dr">有效的DataReader对象</param>
/// <param name="columnNames">该数据传输对象中对应的数据库表的字段（列）名</param>
/// <returns>数据传输对象实例</returns>
protected override DimensionNumberType DataReaderToEntity(SqlDataReader dr, MetaDataTable metaDataTable, params string[] columnNames)
{
if (dr == null)
{
throw new ArgumentNullException("dr", "未将对象引用到实例");
}
return(EntityMapper.GetEntity(dr, new DimensionNumberType(), DimensionNumberType.ENTITYNAME));
}
/// <summary>
/// 将DataReader的属性值转化为实体类的属性值，返回实体类
/// </summary>
/// <param name="dr">有效的DataReader对象</param>
/// <param name="columnNames">该数据传输对象中对应的数据库表的字段（列）名</param>
/// <returns>数据传输对象实例</returns>
protected override OmissionValue DataReaderToEntity(MySqlDataReader dr, MetaDataTable metaDataTable, params string[] columnNames)
{
if (dr == null)
{
throw new ArgumentNullException("dr", "未将对象引用到实例");
}
return(EntityMapper.GetEntity(dr, new OmissionValue(), OmissionValue.ENTITYNAME));
}
protected override CategoryDTO DataReaderToEntity(MySqlDataReader dr, MetaDataTable metaDataTable, params string[] columnNames)
{
if (dr == null)
{
throw new ArgumentNullException("dr", "未将对象引用到实例");
}
return(EntityMapper.GetEntity(dr, new CategoryDTO(), metaDataTable));
}
private byte GetIndexSize(MetaDataTableType type)
{
MetaDataTable table = tablesHeap.Tables[(int)type];
if (table != null && table.IsLarge(0))
{
return(sizeof(uint));
}
return(sizeof(ushort));
}
private void ExtractExtendedData()
{
//Dictionary<int, KeyValuePair<string, string>> metadataProperties = GetFileProperties();
List <KeyValuePair <string, string> > propertyList = GetExtendedDataProperties();
foreach (KeyValuePair <string, string> property in propertyList)
{
MetaDataTable.Rows.Add("ExtendedData", property.Key, property.Value);
MetaDataTable.AcceptChanges();
}
}
internal object ProcessIndex(MetaDataTable table, uint index)
{
if (table == null || !table.IsLarge(0))
{
return((ushort)index);
}
else
{
return(index);
}
}
public void SetMetaDataForColumn(MetaDataTable metaDataTable, string columnName)
{
if (!_table.Columns.ContainsName(columnName))
{
return;
}
var column = _table.Columns.ItemByName(columnName);
setMetaData(column.MetaData, metaDataTable);
ReflectMetaDataChangesForColumn(column);
}
private void AddTables()
{
// use reflection to find all ControlTable derivatives...
Type[] tableTypes = GetControlTableTypes();
// create an instance of each table and add to the table builder...
foreach (var tableType in tableTypes)
{
MetaDataTable t = (MetaDataTable)Activator.CreateInstance(tableType);
AddTable(t);
}
}
internal void SetMetaDataForTable(MetaDataTable metaData)
{
if (_metaDataControl == null)
{
return;
}
_gridPresenter.SetMetaDataForTable(metaData);
MetaDataChanged?.Invoke(this, new EventArgs());
_metaDataControl.RefreshData(0);
}
/// <summary>
/// This method opens an edit dialog for meta data.
/// </summary>
/// <param name="metaData">Meta data to be edited.</param>
/// <param name="column">Grid column of column the meta data belong to.</param>
private void openEditMetaDataForColumn(MetaDataTable metaData, GridColumn column)
{
var icon = (ParentForm == null) ? ApplicationIcons.EmptyIcon : ParentForm.Icon;
var frm = new EditMetaDataView(metaData)
{
StartPosition = FormStartPosition.CenterParent, Icon = icon
};
frm.OnCopyMetaData += (o, e) => OnEvent(() => onCopyMetaDataColumnControl(metaData, column));
if (frm.ShowDialog() == DialogResult.OK)
{
_presenter.SetMetaDataForColumn(metaData, column.FieldName);
}
}
/// <summary>
/// 创建实体集合对应的DataTable对象
/// </summary>
/// <param name="metaDataTable">MetaDataTable对象</param>
/// <param name="entities">实体记录集合</param>
/// <param name="columnNames">目标表列名集合</param>
/// <returns>DataTable对象</returns>
private DataTable GetDataTable(List <T> entities, MetaDataTable metaDataTable, params string[] columnNames)
{
DataTable dataTable = new DataTable(this._tableName);
this.SetDataColumns(dataTable, metaDataTable, columnNames);
foreach (T entity in entities)
{
DataRow dr = dataTable.NewRow();
foreach (DataColumn dataColumn in dataTable.Columns)
{
var metaDataColumn = metaDataTable.Columns[dataColumn.ColumnName];
dr[dataColumn.ColumnName] = metaDataColumn.Member.GetValue(entity, null);
}
dataTable.Rows.Add(dr);
}
return(dataTable);
}
public void AddTable(MetaDataTableType type)
{
MetaDataTable table = new MetaDataTable(this, true);
table._type = type;
_tables[(int)type] = table;
MaskValid |= ((ulong)1 << (int)type);
}
protected void Setup()
{
CategoryDTO category = new CategoryDTO();
this._metaDataTable = new MetaDataTable(category.GetType(), CategoryDTO.ENTITYNAME);
}
protected void Dispose()
{
this._metaDataTable = null;
}
private bool GetRowAndType(BinaryReader reader, MetaDataTable table, out MetaDataRow row, out Type type)
{
type = null;
row = default(MetaDataRow);
switch (table.Type)
{
case MetaDataTableType.Module:
row = ReadRow(reader, GetModuleSignature()); type = typeof(ModuleDefinition); break;
case MetaDataTableType.TypeRef:
row = ReadRow(reader, GetTypeRefSignature()); type = typeof(TypeReference); break;
case MetaDataTableType.TypeDef:
row = ReadRow(reader, GetTypeDefSignature()); type = typeof(TypeDefinition); break;
case MetaDataTableType.FieldPtr:
row = ReadRow(reader, GetFieldPtrSignature()); type = typeof(FieldPtr); break;
case MetaDataTableType.Field:
row = ReadRow(reader, GetFieldDefSignature()); type = typeof(FieldDefinition); break;
case MetaDataTableType.MethodPtr:
row = ReadRow(reader, GetMethodPtrSignature()); type = typeof(MethodPtr); break;
case MetaDataTableType.Method:
row = ReadRow(reader, GetMethodDefSignature()); type = typeof(MethodDefinition); break;
case MetaDataTableType.ParamPtr:
row = ReadRow(reader, GetParamPtrSignature()); type = typeof(ParamPtr); break;
case MetaDataTableType.Param:
row = ReadRow(reader, GetParamDefSignature()); type = typeof(ParameterDefinition); break;
case MetaDataTableType.InterfaceImpl:
row = ReadRow(reader, GetInterfaceImplSignature()); type = typeof(InterfaceImplementation); break;
case MetaDataTableType.MemberRef:
row = ReadRow(reader, GetMemberRefSignature());
tablesHeap._netheader.BlobHeap._mainStream.Seek(Convert.ToUInt32(row._parts[2]), SeekOrigin.Begin);
tablesHeap._netheader.BlobHeap._binReader.ReadByte();
byte sigtype = tablesHeap._netheader.BlobHeap._binReader.ReadByte();
if (sigtype == 0x6)
type = typeof(FieldReference);
else
type = typeof(MethodReference);
break;
case MetaDataTableType.Constant:
row = ReadRow(reader, GetConstantSignature()); type = typeof(Constant); break;
case MetaDataTableType.CustomAttribute:
row = ReadRow(reader, GetCustomAttributeSignature()); type = typeof(CustomAttribute); break;
case MetaDataTableType.FieldMarshal:
row = ReadRow(reader, GetFieldMarshalSignature()); type = typeof(FieldMarshal); break;
case MetaDataTableType.DeclSecurity:
row = ReadRow(reader, GetSecurityDeclSignature()); type = typeof(SecurityDeclaration); break;
case MetaDataTableType.ClassLayout:
row = ReadRow(reader, GetClassLayoutSignature()); type = typeof(ClassLayout); break;
case MetaDataTableType.FieldLayout:
row = ReadRow(reader, GetFieldLayoutSignature()); type = typeof(FieldLayout); break;
case MetaDataTableType.StandAloneSig:
row = ReadRow(reader, GetStandAloneSigSignature()); type = typeof(StandAloneSignature); break;
case MetaDataTableType.EventMap:
row = ReadRow(reader, GetEventMapSignature()); type = typeof(EventMap); break;
case MetaDataTableType.Event:
row = ReadRow(reader, GetEventDefSignature()); type = typeof(EventDefinition); break;
case MetaDataTableType.PropertyMap:
row = ReadRow(reader, GetPropertyMapSignature()); type = typeof(PropertyMap); break;
case MetaDataTableType.PropertyPtr:
row = ReadRow(reader, GetPropertyPtrSignature()); type = typeof(PropertyPtr); break;
case MetaDataTableType.Property:
row = ReadRow(reader, GetPropertyDefSignature()); type = typeof(PropertyDefinition); break;
case MetaDataTableType.MethodSemantics:
row = ReadRow(reader, GetMethodSemanticsSignature()); type = typeof(MethodSemantics); break;
case MetaDataTableType.MethodImpl:
row = ReadRow(reader, GetMethodImplSignature()); type = typeof(MethodImplementation); break;
case MetaDataTableType.ModuleRef:
row = ReadRow(reader, GetModuleRefSignature()); type = typeof(ModuleReference); break;
case MetaDataTableType.TypeSpec:
row = ReadRow(reader, GetTypeSpecSignature()); type = typeof(TypeSpecification); break;
case MetaDataTableType.MethodSpec:
row = ReadRow(reader, GetMethodSpecSignature()); type = typeof(MethodSpecification); break;
case MetaDataTableType.ImplMap:
row = ReadRow(reader, GetPInvokeImplSignature()); type = typeof(PInvokeImplementation); break;
case MetaDataTableType.FieldRVA:
row = ReadRow(reader, GetFieldRVASignature()); type = typeof(FieldRVA); break;
case MetaDataTableType.Assembly:
row = ReadRow(reader, GetAssemblyDefSignature()); type = typeof(AssemblyDefinition); break;
case MetaDataTableType.AssemblyProcessor:
row = ReadRow(reader, GetAssemblyProcSignature()); type = typeof(AssemblyProcessor); break;
case MetaDataTableType.AssemblyOS:
row = ReadRow(reader, GetAssemblyOSSignature()); type = typeof(AssemblyOS); break;
case MetaDataTableType.AssemblyRef:
row = ReadRow(reader, GetAssemblyRefSignature()); type = typeof(AssemblyReference); break;
case MetaDataTableType.AssemblyRefProcessor:
row = ReadRow(reader, GetAssemblyRefProcSignature()); type = typeof(AssemblyRefProcessor); break;
case MetaDataTableType.AssemblyRefOS:
row = ReadRow(reader, GetAssemblyRefOSSignature()); type = typeof(AssemblyRefOS); break;
case MetaDataTableType.File:
row = ReadRow(reader, GetFileReferenceSignature()); type = typeof(File); break;
case MetaDataTableType.ExportedType:
row = ReadRow(reader, GetExportedTypeSignature()); type = typeof(ExportedType); break;
case MetaDataTableType.ManifestResource:
row = ReadRow(reader, GetManifestResSignature()); type = typeof(ManifestResource); break;
case MetaDataTableType.NestedClass:
row = ReadRow(reader, GetNestedClassSignature()); type = typeof(NestedClass); break;
case MetaDataTableType.EncLog:
row = ReadRow(reader, GetEnCLogSignature()); type = typeof(EnCLog); break;
case MetaDataTableType.EncMap:
row = ReadRow(reader, GetEnCMapSignature()); type = typeof(EnCMap); break;
case MetaDataTableType.GenericParam:
row = ReadRow(reader, GetGenericParamSignature()); type = typeof(GenericParameter); break;
case MetaDataTableType.GenericParamConstraint:
row = ReadRow(reader, GetGenericParamConstraintSignature()); type = typeof(GenericParamConstraint); break;
}
return type != null;
}
internal MetaRow(System.Data.DataRowBuilder builder) :
base(builder) {
this.tableMeta = ((MetaDataTable)(this.Table));
}
internal MetaDataTable CreateTable(MetaDataTableType type, int rowAmount, long rowAmountOffset)
{
//customattribute[permission]?
MetaDataTable table = new MetaDataTable(tablesHeap, false);
table.Type = type;
table._rowAmount = rowAmount;
table._rowAmountOffset = rowAmountOffset;
switch (type)
{
case MetaDataTableType.Assembly:
tablesHeap.HasCustomAttribute[14] = table;
tablesHeap.HasDeclSecurity[2] = table;
break;
case MetaDataTableType.AssemblyRef:
tablesHeap.HasCustomAttribute[15] = table;
tablesHeap.Implementation[1] = table;
tablesHeap.ResolutionScope[2] = table;
break;
case MetaDataTableType.Event:
tablesHeap.HasCustomAttribute[10] = table;
tablesHeap.HasSemantics[0] = table;
break;
case MetaDataTableType.ExportedType:
tablesHeap.HasCustomAttribute[17] = table;
tablesHeap.Implementation[2] = table;
break;
case MetaDataTableType.Field:
tablesHeap.HasConstant[0] = table;
tablesHeap.HasCustomAttribute[1] = table;
tablesHeap.HasFieldMarshall[0] = table;
tablesHeap.MemberForwarded[0] = table;
break;
case MetaDataTableType.File:
tablesHeap.HasCustomAttribute[16] = table;
tablesHeap.Implementation[0] = table;
break;
case MetaDataTableType.GenericParam:
tablesHeap.HasCustomAttribute[19] = table;
break;
case MetaDataTableType.GenericParamConstraint:
tablesHeap.HasCustomAttribute[20] = table;
break;
case MetaDataTableType.InterfaceImpl:
tablesHeap.HasCustomAttribute[5] = table;
break;
case MetaDataTableType.ManifestResource:
tablesHeap.HasCustomAttribute[18] = table;
break;
case MetaDataTableType.MemberRef:
tablesHeap.HasCustomAttribute[6] = table;
tablesHeap.MethodDefOrRef[1] = table;
tablesHeap.CustomAttributeType[3] = table;
break;
case MetaDataTableType.Method:
tablesHeap.HasCustomAttribute[0] = table;
tablesHeap.HasDeclSecurity[1] = table;
tablesHeap.MemberRefParent[3] = table;
tablesHeap.MethodDefOrRef[0] = table;
tablesHeap.MemberForwarded[1] = table;
tablesHeap.CustomAttributeType[2] = table;
tablesHeap.TypeOrMethod[1] = table;
break;
case MetaDataTableType.MethodSpec:
tablesHeap.HasCustomAttribute[21] = table;
break;
case MetaDataTableType.Module:
tablesHeap.HasCustomAttribute[7] = table;
tablesHeap.ResolutionScope[0] = table;
break;
case MetaDataTableType.ModuleRef:
tablesHeap.HasCustomAttribute[12] = table;
tablesHeap.MemberRefParent[2] = table;
tablesHeap.ResolutionScope[1] = table;
break;
case MetaDataTableType.Param:
tablesHeap.HasConstant[1] = table;
tablesHeap.HasCustomAttribute[4] = table;
tablesHeap.HasFieldMarshall[1] = table;
break;
case MetaDataTableType.Property:
tablesHeap.HasConstant[2] = table;
tablesHeap.HasCustomAttribute[9] = table;
tablesHeap.HasSemantics[1] = table;
break;
case MetaDataTableType.StandAloneSig:
tablesHeap.HasCustomAttribute[11] = table;
break;
case MetaDataTableType.TypeDef:
tablesHeap.TypeDefOrRef[0] = table;
tablesHeap.HasCustomAttribute[3] = table;
tablesHeap.HasDeclSecurity[0] = table;
tablesHeap.MemberRefParent[0] = table;
tablesHeap.TypeOrMethod[0] = table;
break;
case MetaDataTableType.TypeRef:
tablesHeap.TypeDefOrRef[1] = table;
tablesHeap.HasCustomAttribute[2] = table;
tablesHeap.MemberRefParent[1] = table;
tablesHeap.ResolutionScope[3] = table;
break;
case MetaDataTableType.TypeSpec:
tablesHeap.TypeDefOrRef[2] = table;
tablesHeap.HasCustomAttribute[13] = table;
tablesHeap.MemberRefParent[4] = table;
break;
}
return table;
}
internal void InitializeClass() {
this.DataSetName = "SuposDataSet";
this.Prefix = "";
this.Namespace = "http://tempuri.org/TestDataSet.xsd";
this.Locale = new System.Globalization.CultureInfo("fr-BE");
this.CaseSensitive = false;
this.EnforceConstraints = true;
this.__tableCategories = new CategoriesDataTable();
this.Tables.Add(this.__tableCategories);
this.__tableProducts = new ProductsDataTable();
this.Tables.Add(this.__tableProducts);
this.__tableTaxes = new TaxesDataTable();
this.Tables.Add(this.__tableTaxes);
this.__tableCustomers = new CustomersDataTable();
this.Tables.Add(this.__tableCustomers);
this.__tableOrders = new OrdersDataTable();
this.Tables.Add(this.__tableOrders);
this.__tableOrderDetails = new OrderDetailsDataTable();
this.Tables.Add(this.__tableOrderDetails);
this.__tablePayments = new PaymentsDataTable();
this.Tables.Add(this.__tablePayments);
this.__tableMeta = new MetaDataTable();
this.Tables.Add(this.__tableMeta);
System.Data.UniqueConstraint uc;
uc = new System.Data.UniqueConstraint("PK_Categories", new System.Data.DataColumn[] {
this.__tableCategories.Columns["Id"]}, true);
this.__tableCategories.Constraints.Add(uc);
uc = new System.Data.UniqueConstraint("PK_Products", new System.Data.DataColumn[] {
this.__tableProducts.Columns["Id"]}, true);
this.__tableProducts.Constraints.Add(uc);
uc = new System.Data.UniqueConstraint("PK_Taxes", new System.Data.DataColumn[] {
this.__tableTaxes.Columns["Id"]}, true);
this.__tableTaxes.Constraints.Add(uc);
uc = new System.Data.UniqueConstraint("PK_Clients", new System.Data.DataColumn[] {
this.__tableCustomers.Columns["Id"]}, true);
this.__tableCustomers.Constraints.Add(uc);
uc = new System.Data.UniqueConstraint("PK_Orders", new System.Data.DataColumn[] {
this.__tableOrders.Columns["Id"]}, true);
this.__tableOrders.Constraints.Add(uc);
uc = new System.Data.UniqueConstraint("PK_OrderDetails", new System.Data.DataColumn[] {
this.__tableOrderDetails.Columns["Id"]}, true);
this.__tableOrderDetails.Constraints.Add(uc);
uc = new System.Data.UniqueConstraint("PK_Payment", new System.Data.DataColumn[] {
this.__tablePayments.Columns["Id"]}, true);
this.__tablePayments.Constraints.Add(uc);
uc = new System.Data.UniqueConstraint("PK_Meta", new System.Data.DataColumn[] {
this.__tableMeta.Columns["Id"]}, true);
this.__tableMeta.Constraints.Add(uc);
System.Data.ForeignKeyConstraint fkc;
fkc = new System.Data.ForeignKeyConstraint("FK_Categories_Products", new System.Data.DataColumn[] {
this.__tableCategories.Columns["Id"]}, new System.Data.DataColumn[] {
this.__tableProducts.Columns["CategoryId"]});
fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
fkc.DeleteRule = System.Data.Rule.Cascade;
fkc.UpdateRule = System.Data.Rule.Cascade;
this.__tableProducts.Constraints.Add(fkc);
fkc = new System.Data.ForeignKeyConstraint("FK_Taxes_Products", new System.Data.DataColumn[] {
this.__tableTaxes.Columns["Id"]}, new System.Data.DataColumn[] {
this.__tableProducts.Columns["DefaultTaxId"]});
fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
fkc.DeleteRule = System.Data.Rule.Cascade;
fkc.UpdateRule = System.Data.Rule.Cascade;
this.__tableProducts.Constraints.Add(fkc);
fkc = new System.Data.ForeignKeyConstraint("FK_Customers_Orders", new System.Data.DataColumn[] {
this.__tableCustomers.Columns["Id"]}, new System.Data.DataColumn[] {
this.__tableOrders.Columns["CustomerId"]});
fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
fkc.DeleteRule = System.Data.Rule.Cascade;
fkc.UpdateRule = System.Data.Rule.Cascade;
this.__tableOrders.Constraints.Add(fkc);
fkc = new System.Data.ForeignKeyConstraint("FK_Orders_OrderDetails", new System.Data.DataColumn[] {
this.__tableOrders.Columns["Id"]}, new System.Data.DataColumn[] {
this.__tableOrderDetails.Columns["OrderId"]});
fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
fkc.DeleteRule = System.Data.Rule.Cascade;
fkc.UpdateRule = System.Data.Rule.Cascade;
this.__tableOrderDetails.Constraints.Add(fkc);
fkc = new System.Data.ForeignKeyConstraint("PK_Products_OrderDetails", new System.Data.DataColumn[] {
this.__tableProducts.Columns["Id"]}, new System.Data.DataColumn[] {
this.__tableOrderDetails.Columns["ProductId"]});
fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
fkc.DeleteRule = System.Data.Rule.Cascade;
fkc.UpdateRule = System.Data.Rule.Cascade;
this.__tableOrderDetails.Constraints.Add(fkc);
fkc = new System.Data.ForeignKeyConstraint("PK_Taxes_OrderDetails", new System.Data.DataColumn[] {
this.__tableTaxes.Columns["Id"]}, new System.Data.DataColumn[] {
this.__tableOrderDetails.Columns["TaxId"]});
fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
fkc.DeleteRule = System.Data.Rule.Cascade;
fkc.UpdateRule = System.Data.Rule.Cascade;
this.__tableOrderDetails.Constraints.Add(fkc);
this.__relationFK_Orders_OrderDetailsRelation = new System.Data.DataRelation("FK_Orders_OrderDetails", new System.Data.DataColumn[] {
this.__tableOrders.Columns["Id"]}, new System.Data.DataColumn[] {
this.__tableOrderDetails.Columns["OrderId"]}, false);
this.__relationFK_Orders_OrderDetailsRelation.Nested = false;
this.Relations.Add(this.__relationFK_Orders_OrderDetailsRelation);
this.__relationPK_Products_OrderDetailsRelation = new System.Data.DataRelation("PK_Products_OrderDetails", new System.Data.DataColumn[] {
this.__tableProducts.Columns["Id"]}, new System.Data.DataColumn[] {
this.__tableOrderDetails.Columns["ProductId"]}, false);
this.__relationPK_Products_OrderDetailsRelation.Nested = false;
this.Relations.Add(this.__relationPK_Products_OrderDetailsRelation);
this.__relationPK_Taxes_OrderDetailsRelation = new System.Data.DataRelation("PK_Taxes_OrderDetails", new System.Data.DataColumn[] {
this.__tableTaxes.Columns["Id"]}, new System.Data.DataColumn[] {
this.__tableOrderDetails.Columns["TaxId"]}, false);
this.__relationPK_Taxes_OrderDetailsRelation.Nested = false;
this.Relations.Add(this.__relationPK_Taxes_OrderDetailsRelation);
this.__relationFK_Customers_OrdersRelation = new System.Data.DataRelation("FK_Customers_Orders", new System.Data.DataColumn[] {
this.__tableCustomers.Columns["Id"]}, new System.Data.DataColumn[] {
this.__tableOrders.Columns["CustomerId"]}, false);
this.__relationFK_Customers_OrdersRelation.Nested = false;
this.Relations.Add(this.__relationFK_Customers_OrdersRelation);
this.__relationFK_Categories_ProductsRelation = new System.Data.DataRelation("FK_Categories_Products", new System.Data.DataColumn[] {
this.__tableCategories.Columns["Id"]}, new System.Data.DataColumn[] {
this.__tableProducts.Columns["CategoryId"]}, false);
this.__relationFK_Categories_ProductsRelation.Nested = false;
this.Relations.Add(this.__relationFK_Categories_ProductsRelation);
this.__relationFK_Taxes_ProductsRelation = new System.Data.DataRelation("FK_Taxes_Products", new System.Data.DataColumn[] {
this.__tableTaxes.Columns["Id"]}, new System.Data.DataColumn[] {
this.__tableProducts.Columns["DefaultTaxId"]}, false);
this.__relationFK_Taxes_ProductsRelation.Nested = false;
this.Relations.Add(this.__relationFK_Taxes_ProductsRelation);
this.__relationR_Taxes_OrdersRelation = new System.Data.DataRelation("R_Taxes_Orders", new System.Data.DataColumn[] {
this.__tableTaxes.Columns["Id"]}, new System.Data.DataColumn[] {
this.__tableOrders.Columns["TaxId"]}, false);
this.__relationR_Taxes_OrdersRelation.Nested = false;
this.Relations.Add(this.__relationR_Taxes_OrdersRelation);
this.__relationR_Payments_OrdersRelation = new System.Data.DataRelation("R_Payments_Orders", new System.Data.DataColumn[] {
this.__tablePayments.Columns["Id"]}, new System.Data.DataColumn[] {
this.__tableOrders.Columns["PaymentId"]}, false);
this.__relationR_Payments_OrdersRelation.Nested = false;
this.Relations.Add(this.__relationR_Payments_OrdersRelation);
}
internal MetaDataMember ReadMember(MetaDataTable table, int index)
{
using (MemoryStream stream = new MemoryStream(tablesHeap.Contents))
{
using (BinaryReader reader = new BinaryReader(stream))
{
stream.Position = table.TableOffset - tablesHeap.StreamOffset;
stream.Position += (table.CalculateRowSize() * (index - 1));
Type type;
MetaDataRow row;
if (GetRowAndType(reader, table, out row, out type))
{
return CreateMember(type, row, table.Type, index);
}
}
}
return null;
}
