/// <summary>
/// 根据实体属性查询实体
/// </summary>
/// <param name="pTableInfo">表信息</param>
/// <param name="pDaoConstructorParams">Dao构造器参数</param>
/// <param name="pEntityProperty">实体属性字典</param>
/// <returns>查询结果</returns>
public static object[] QueryByEntity(ETCLTable pTableInfo, object[] pDaoConstructorParams, Dictionary <string, object> pEntityProperty)
{
try
{
string pDaoDLL = pTableInfo.DAOAssemblyName;
string pDaoClassFullName = pTableInfo.DAOName;
string pEntityDLL = pTableInfo.EntityAssemblyName;
string pEntityFullName = pTableInfo.EntityName;
if (string.IsNullOrWhiteSpace(pDaoDLL))
{
pDaoDLL = "TenantPlatform.DataAccess.dll";
}
if (pDaoClassFullName == null)
{
pDaoClassFullName = "JIT.TenantPlatform.DataAccess." + pTableInfo.TableName + "DAO";
}
if (string.IsNullOrWhiteSpace(pEntityDLL))
{
pEntityDLL = "TenantPlatform.Entity.dll";
}
if (pEntityFullName == null)
{
pEntityFullName = "JIT.TenantPlatform.Entity." + pTableInfo.TableName + "Entity";
}
string assemblyPath;
if (System.Environment.CurrentDirectory == AppDomain.CurrentDomain.BaseDirectory)
{//Winform
assemblyPath = AppDomain.CurrentDomain.BaseDirectory;
}
else
{//Web
assemblyPath = AppDomain.CurrentDomain.BaseDirectory + "Bin/";
}
object oDAO = JIT.Utility.Reflection.DynamicReflectionHandler.CreateInstance(assemblyPath + pDaoDLL, pDaoClassFullName, pDaoConstructorParams);
object oEntity = JIT.Utility.Reflection.DynamicReflectionHandler.CreateInstance(assemblyPath + pEntityDLL, pEntityFullName, null);
foreach (var item in pEntityProperty)
{
JIT.Utility.Reflection.DynamicReflectionHandler.SetProperty(oEntity, item.Key, item.Value);
}
object oResult = JIT.Utility.Reflection.DynamicReflectionHandler.CallFunction(oDAO, "QueryByEntity", new object[] { oEntity, null });
if (oResult == null)
{
return(null);
}
object[] oResults = oResult as object[];
return(oResults);
}
catch (System.Reflection.TargetInvocationException ex)
{
Loggers.Exception(new ExceptionLogInfo(ex.InnerException));
throw ex.InnerException;
}
}
/// <summary>
/// 创建Entity到数据库表
/// </summary>
/// <param name="pTableInfo">表信息</param>
/// <param name="pDaoConstructorParams">Dao构造器参数</param>
/// <param name="object">实体对象</param>
/// <param name="pTran">数据库事务</param>
/// <returns>创建结果</returns>
public static object CreateEntity(ETCLTable pTableInfo, object[] pDaoConstructorParams, object pEntity, IDbTransaction pTran)
{
try
{
string pDaoDLL = pTableInfo.DAOAssemblyName;
string pDaoClassFullName = pTableInfo.DAOName;
string pEntityDLL = pTableInfo.EntityAssemblyName;
string pEntityFullName = pTableInfo.EntityName;
if (string.IsNullOrWhiteSpace(pDaoDLL))
{
pDaoDLL = "TenantPlatform.DataAccess.dll";
}
if (string.IsNullOrEmpty(pDaoClassFullName))
{
pDaoClassFullName = "JIT.TenantPlatform.DataAccess." + pTableInfo.TableName + "DAO";
}
if (string.IsNullOrEmpty(pEntityDLL))
{
pEntityDLL = "TenantPlatform.Entity.dll";
}
if (string.IsNullOrEmpty(pEntityFullName))
{
pEntityFullName = "JIT.TenantPlatform.Entity." + pTableInfo.TableName + "Entity";
}
string assemblyPath;
if (System.Environment.CurrentDirectory == AppDomain.CurrentDomain.BaseDirectory)
{//Winform
assemblyPath = AppDomain.CurrentDomain.BaseDirectory;
}
else
{//Web
assemblyPath = AppDomain.CurrentDomain.BaseDirectory + "Bin/";
}
object oDAO = JIT.Utility.Reflection.DynamicReflectionHandler.CreateInstance(assemblyPath + pDaoDLL, pDaoClassFullName, pDaoConstructorParams);
return(JIT.Utility.Reflection.DynamicReflectionHandler.CallFunction(oDAO, "Create", new object[] { pEntity, pTran }));
}
catch (System.Reflection.TargetInvocationException ex)
{
Loggers.Exception(new ExceptionLogInfo(ex.InnerException));
throw ex.InnerException;
}
}
/// <summary>
/// 执行检查
/// </summary>
/// <param name="pPropertyValue">待检查的数据值</param>
/// <param name="pPropertyText">此数据的属性名称（列描述）</param>
/// <param name="pRowData">当前数据项的信息</param>
/// <param name="oResult">检查结果</param>
/// <returns>TRUE：通过检查，FALSE：未通过检查。</returns>
public bool Process(object pPropertyValue, string pPropertyText, IETCLDataItem pRowData, ref IETCLResultItem oResult)
{
bool isPass = true;
if (pPropertyValue == null || string.IsNullOrWhiteSpace(pPropertyValue.ToString()))//空值不检查依赖项
{
return(true);
}
//检查当前XLS中是否有此依赖表
ETCLTable referenceTable = this._etclWorksheet.GetTableByName(this._etclColumn.ReferenceTableName);
if (referenceTable == null)
{
throw new ETCLException(200, string.Format("未找到关联表的相关定义，请修改XML配置。列名:{0},关联表:{1}", this._etclColumn.ColumnName, this._etclColumn.ReferenceTableName));
}
//通过反射从数据库中读取此依赖表信息
if (!_dictCachedReference.ContainsKey(this._etclColumn.ReferenceTableName))
{
object[] oTempEntities = Reflection.DynamicReflectionHandler.QueryAll(referenceTable, new object[] { this._userInfo });
_dictCachedReference.Add(this._etclColumn.ReferenceTableName, oTempEntities);
}
object[] oEntities = _dictCachedReference[this._etclColumn.ReferenceTableName];
foreach (var entityItem in oEntities)
{
object oTempValue = Reflection.DynamicReflectionHandler.GetProperty(entityItem, this._etclColumn.ReferenceTextColumnName);
if (oTempValue.Equals(pPropertyValue))
{
isPass = false;
oResult = new ETCLCommonResultItem();
oResult.OPType = OperationType.ForeignKeyDependence;
oResult.Message = string.Format("[{数据项:{0}}]的数据在关联表中不存在.", pPropertyText);
}
}
return(isPass);
}
///// <summary>
///// 所有转换器
///// </summary>
//protected Dictionary<ITransformer, List<string>> AllTransformer;
/// <summary>
/// 构造器
/// </summary>
/// <param name="pUserInfo">用户信息</param>
public CommonExcelETCL(BasicUserInfo pUserInfo)
{
//从XML加载列及模板信息
this._currentBusinessInfo = new ETCLTemplateInfo();
this._currentBusinessInfo.Lang = (int)Reflection.DynamicReflectionHandler.GetProperty(pUserInfo, "Lang");
this.CurrentUserInfo = pUserInfo;
XmlDocument xmlDoc = new XmlDocument();
string xmlPath = AppDomain.CurrentDomain.BaseDirectory + "\\ETCLConfig.xml";
xmlDoc.Load(xmlPath);
List <XmlNode> lstTemplates = XMLHandler.GetNodesByProperty(xmlDoc, "JitETCLTemplates/JitETCLTemplate", "ClientID", pUserInfo.ClientID);
if (this._currentBusinessInfo.Lang == 2)
{
this._currentBusinessInfo.TemplateName = lstTemplates[0].Attributes["TemplateNameEn"].Value;
}
else
{
this._currentBusinessInfo.TemplateName = lstTemplates[0].Attributes["TemplateName"].Value;
}
this._currentBusinessInfo.TemplateDescription = lstTemplates[0].Attributes["TemplateDescription"].Value;
this._currentBusinessInfo.WorkSheets = new List <ETCLWorkSheetInfo>();
//加载Worksheets
foreach (XmlNode worksheetItem in lstTemplates[0].ChildNodes)
{
ETCLWorkSheetInfo worksheetInfo = new ETCLWorkSheetInfo();
worksheetInfo.Transformers = new List <ITransformer>();
worksheetInfo.Transformers.Add(new DefaultTransformer(worksheetInfo));
worksheetInfo.Tables = new List <ETCLTable>();
if (this._currentBusinessInfo.Lang == 2)
{
worksheetInfo.WorkSheetName = worksheetItem.Attributes["WorkSheetNameEn"].Value;
}
else
{
worksheetInfo.WorkSheetName = worksheetItem.Attributes["WorkSheetName"].Value;
}
worksheetInfo.WorkSheetDescription = worksheetItem.Attributes["WorkSheetDescription"].Value;
worksheetInfo.Index = this._currentBusinessInfo.WorkSheets.Count;
this._currentBusinessInfo.WorkSheets.Add(worksheetInfo);
//加载 当前Worksheet所涉及到的数据表
foreach (XmlNode tableItem in worksheetItem.ChildNodes)
{
ETCLTable etclTable = new ETCLTable();
etclTable.Columns = new List <ETCLColumn>();
etclTable.TableName = tableItem.Attributes["TableName"].Value;
if (this._currentBusinessInfo.Lang == 2)
{
etclTable.TableDesc = tableItem.Attributes["TableDescEn"].Value;
}
else
{
etclTable.TableDesc = tableItem.Attributes["TableDesc"].Value;
}
if (tableItem.Attributes["ReferenceOnly"] != null && !string.IsNullOrWhiteSpace(tableItem.Attributes["ReferenceOnly"].Value))
{
etclTable.ReferenceOnly = Convert.ToInt32(tableItem.Attributes["ReferenceOnly"].Value);
}
if (tableItem.Attributes["DAOAssemblyName"] != null)
{
etclTable.DAOAssemblyName = tableItem.Attributes["DAOAssemblyName"].Value;
}
if (tableItem.Attributes["EntityAssemblyName"] != null)
{
etclTable.EntityAssemblyName = tableItem.Attributes["EntityAssemblyName"].Value;
}
if (tableItem.Attributes["DAOName"] != null)
{
etclTable.DAOName = tableItem.Attributes["DAOName"].Value;
}
if (tableItem.Attributes["EntityName"] != null)
{
etclTable.EntityName = tableItem.Attributes["EntityName"].Value;
}
etclTable.ReferenceDepth = 0;
etclTable.Worksheet = worksheetInfo;
etclTable.Index = worksheetInfo.Tables.Count;
etclTable.Loaders = new List <ILoader>();
etclTable.Loaders.Add(new DefaultLoader());
worksheetInfo.Tables.Add(etclTable);
//加载表中的列
foreach (XmlNode columnItem in tableItem.ChildNodes)
{
ETCLColumn etclColumnInfo = new ETCLColumn();
if (columnItem.Attributes["ColumnName"] != null)
{
etclColumnInfo.ColumnName = columnItem.Attributes["ColumnName"].Value;
}
if (this._currentBusinessInfo.Lang == 2)
{
if (columnItem.Attributes["ColumnTextEn"] != null)
{
etclColumnInfo.ColumnText = columnItem.Attributes["ColumnTextEn"].Value;
}
}
else
{
if (columnItem.Attributes["ColumnText"] != null)
{
etclColumnInfo.ColumnText = columnItem.Attributes["ColumnText"].Value;
}
}
if (columnItem.Attributes["ColumnType"] != null)
{
etclColumnInfo.ColumnType = columnItem.Attributes["ColumnType"].Value;
}
if (columnItem.Attributes["Visible"] != null)
{
if (!string.IsNullOrEmpty(columnItem.Attributes["Visible"].Value))
{
etclColumnInfo.Visible = columnItem.Attributes["Visible"].Value != "0";
}
}
if (columnItem.Attributes["Nullable"] != null)
{
if (!string.IsNullOrEmpty(columnItem.Attributes["Nullable"].Value))
{
etclColumnInfo.Nullable = columnItem.Attributes["Nullable"].Value != "0";
}
}
if (columnItem.Attributes["Duplicatable"] != null)
{
if (!string.IsNullOrEmpty(columnItem.Attributes["Duplicatable"].Value))
{
etclColumnInfo.Duplicatable = columnItem.Attributes["Duplicatable"].Value != "0";
}
}
if (columnItem.Attributes["CanTermReplace"] != null)
{
if (!string.IsNullOrEmpty(columnItem.Attributes["CanTermReplace"].Value))
{
etclColumnInfo.CanTermReplace = columnItem.Attributes["CanTermReplace"].Value != "0";
}
}
if (columnItem.Attributes["IsLogicalField"] != null)
{
if (!string.IsNullOrEmpty(columnItem.Attributes["IsLogicalField"].Value))
{
etclColumnInfo.IsLogicalField = columnItem.Attributes["IsLogicalField"].Value != "0";
}
}
if (columnItem.Attributes["MaxValue"] != null)
{
etclColumnInfo.MaxValue = columnItem.Attributes["MaxValue"].Value;
}
if (columnItem.Attributes["MinValue"] != null)
{
etclColumnInfo.MinValue = columnItem.Attributes["MinValue"].Value;
}
if (columnItem.Attributes["ReferenceTableName"] != null)
{
etclColumnInfo.ReferenceTableName = columnItem.Attributes["ReferenceTableName"].Value;
}
if (columnItem.Attributes["ReferenceAdditionalCondition"] != null)
{
etclColumnInfo.ReferenceAdditionalCondition = columnItem.Attributes["ReferenceAdditionalCondition"].Value;
}
if (columnItem.Attributes["ReferenceColumnName"] != null)
{
etclColumnInfo.ReferenceColumnName = columnItem.Attributes["ReferenceColumnName"].Value;
}
if (this._currentBusinessInfo.Lang == 2)
{
if (columnItem.Attributes["ReferenceTextColumnNameEn"] != null)
{
etclColumnInfo.ReferenceTextColumnName = columnItem.Attributes["ReferenceTextColumnNameEn"].Value;
}
}
else
{
if (columnItem.Attributes["ReferenceTextColumnName"] != null)
{
etclColumnInfo.ReferenceTextColumnName = columnItem.Attributes["ReferenceTextColumnName"].Value;
}
}
etclColumnInfo.ValueCountCache = new Dictionary <object, int>();
etclColumnInfo.ValueCache = new List <object>();
//添加默认Checker
etclColumnInfo.Checkers = new List <IChecker>();
if (etclColumnInfo.Nullable.HasValue && !etclColumnInfo.Nullable.Value)
{
etclColumnInfo.Checkers.Add(new DefaultNullValueChecker());
}
if (etclColumnInfo.Duplicatable.HasValue && !etclColumnInfo.Duplicatable.Value)
{
etclColumnInfo.Checkers.Add(new DefaultDuplicateChecker(this.CurrentUserInfo, etclTable, etclColumnInfo));
}
if (!string.IsNullOrWhiteSpace(etclColumnInfo.MaxValue) || !string.IsNullOrWhiteSpace(etclColumnInfo.MinValue))
{
etclColumnInfo.Checkers.Add(new ValueRangeChecker(etclColumnInfo));
}
etclTable.Columns.Add(etclColumnInfo);
}
}
}
}
/// <summary>
/// 执行转换，并进行文本-键转换
/// </summary>
/// <param name="pDataSource">从数据源取出的直接数据</param>
/// <param name="pUserInfo">用户信息</param>
/// <param name="oData">转换后的数据</param>
/// <param name="oResult">抽取结果详情</param>
/// <returns>TRUE：抽取成功，FALSE：抽取失败。</returns>
public bool Process(DataTable pDataSource, BasicUserInfo pUserInfo, out IETCLDataItem[] oData, out IETCLResultItem[] oCheckResult)
{
bool isPass = true;
List <ETCLCommonResultItem> lstCheckResult = new List <ETCLCommonResultItem>();
////将原始数据按表拆分到各个DataTable
List <CommonExcelDataItem> lstDataItem = new List <CommonExcelDataItem>();
if (pDataSource != null)
{
bool isAllNullOrEmpty = true;
//移除全为null或string.Empty的记录
for (int i = 0; i < pDataSource.Rows.Count; i++)
{
isAllNullOrEmpty = true;
DataRow dr = pDataSource.Rows[i];
for (int j = 0; j < pDataSource.Columns.Count; j++)
{
if (dr[j] != DBNull.Value && dr[j].ToString().Trim() != string.Empty)
{
isAllNullOrEmpty = false;
break;
}
}
if (isAllNullOrEmpty)
{
pDataSource.Rows.RemoveAt(i);
i--;
}
}
pDataSource.AcceptChanges();
foreach (var tableItem in this._workSheetInfo.Tables)
{
if (tableItem.ReferenceOnly == 1)
{
continue;
}
tableItem.Data = pDataSource.Copy();
tableItem.Data.TableName = tableItem.TableName;
Dictionary <string, string> columnTextNameMapping = new Dictionary <string, string>();
foreach (var columnItem in tableItem.Columns)
{
columnTextNameMapping.Add(columnItem.ColumnText, columnItem.ColumnName);
}
//去掉多余列
foreach (DataColumn columnItem in pDataSource.Columns)
{
if (columnTextNameMapping.ContainsKey(columnItem.ColumnName))
{//文本改成列名
tableItem.Data.Columns[columnItem.ColumnName].ColumnName = columnTextNameMapping[columnItem.ColumnName];
}
else
{
tableItem.Data.Columns.Remove(columnItem.ColumnName);
}
}
}
}
else
{
oData = null;
oCheckResult = null;
return(true);
}
string assemblyPath;
if (System.Environment.CurrentDirectory == AppDomain.CurrentDomain.BaseDirectory)
{//Winform
assemblyPath = AppDomain.CurrentDomain.BaseDirectory;
}
else
{//Web
assemblyPath = AppDomain.CurrentDomain.BaseDirectory + "Bin/";
}
//转换到Entity
Dictionary <string, object[]> dictDBTableCache = new Dictionary <string, object[]>();
foreach (var tableItem in this._workSheetInfo.Tables)
{
if (tableItem.Data == null || tableItem.ReferenceOnly == 1)
{
continue;
}
List <CommonExcelDataItem> lstEntity = new List <CommonExcelDataItem>();
Dictionary <string, Dictionary <object, object> > dictCachedReference = new Dictionary <string, Dictionary <object, object> >();
foreach (DataRow tableRowItem in tableItem.Data.Rows)
{
CommonExcelDataItem oInstance = new CommonExcelDataItem();
lstDataItem.Add(oInstance);
oInstance.Table = tableItem;
oInstance.Index = lstEntity.Count;
if (string.IsNullOrEmpty(tableItem.EntityName))
{//使用默认规则创建Entity（TableName+“Entity”）
oInstance.Entity = Reflection.DynamicReflectionHandler.CreateInstance(assemblyPath + "TenantPlatform.Entity.dll", "JIT.TenantPlatform.Entity." + tableItem.TableName + "Entity", null);
}
else
{
oInstance.Entity = Reflection.DynamicReflectionHandler.CreateInstance(assemblyPath + tableItem.EntityAssemblyName, tableItem.EntityName, null);
}
//依次填充属性
foreach (ETCLColumn columnItem in tableItem.Columns)
{//值->键转换处理。
if (!tableItem.Data.Columns.Contains(columnItem.ColumnName))
{
continue;
}
object oCellValue = tableRowItem[columnItem.ColumnName];
columnItem.ValueCache.Add(oCellValue);
object oReferencedID = null;
if (!string.IsNullOrWhiteSpace(columnItem.ReferenceTableName) && !string.IsNullOrWhiteSpace(columnItem.ReferenceColumnName) && !string.IsNullOrWhiteSpace(columnItem.ReferenceTextColumnName))
{
//每个单元格;
if (oCellValue == null || string.IsNullOrWhiteSpace(oCellValue.ToString()))//空值不检查依赖项
{
continue;
}
bool bExists = false;
Dictionary <object, object> dictValuesOfCurrentColumn;
//a.缓存中查找
if (dictCachedReference.ContainsKey(columnItem.ColumnName))
{//缓存中查找
dictValuesOfCurrentColumn = dictCachedReference[columnItem.ColumnName];
if (dictValuesOfCurrentColumn.ContainsKey(oCellValue))
{
bExists = true;
oReferencedID = dictValuesOfCurrentColumn[oCellValue];
}
}
else
{
dictValuesOfCurrentColumn = new Dictionary <object, object>();
dictCachedReference.Add(columnItem.ColumnName, dictValuesOfCurrentColumn);
}
//b.数据库中查找
if (!bExists)
{//通过反射从数据库中读取此依赖表信息
ETCLTable referenceTable = this._workSheetInfo.GetTableByName(columnItem.ReferenceTableName);
object[] oTempEntities;
if (dictDBTableCache.ContainsKey(columnItem.ReferenceTableName))
{
oTempEntities = dictDBTableCache[columnItem.ReferenceTableName];
}
else
{
oTempEntities = Reflection.DynamicReflectionHandler.QueryAll(referenceTable, new object[] { pUserInfo });
dictDBTableCache.Add(columnItem.ReferenceTableName, oTempEntities);
}
foreach (var entityItem in oTempEntities)
{
bool bMached = true;
if (!string.IsNullOrWhiteSpace(columnItem.ReferenceAdditionalCondition))
{//附加条件(如，从Options中查数据时，需要OptionName和OptionValue多个字段)
string[] conditions = columnItem.ReferenceAdditionalCondition.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var conditionItem in conditions)
{
string[] conditionNameValue = conditionItem.Split(new char[] { '=' }, StringSplitOptions.RemoveEmptyEntries);
if (conditionNameValue == null || conditionNameValue.Length != 2)
{
continue;
}
object oValue = Reflection.DynamicReflectionHandler.GetProperty(entityItem, conditionNameValue[0]);
if (oValue == null || oValue.ToString() != conditionNameValue[1])
{
bMached = false;
break;
}
}
if (!bMached)
{
continue;
}
}
object oTempValue = Reflection.DynamicReflectionHandler.GetProperty(entityItem, columnItem.ReferenceTextColumnName);
if (oTempValue != null && oTempValue.Equals(oCellValue))
{
oReferencedID = Reflection.DynamicReflectionHandler.GetProperty(entityItem, columnItem.ReferenceColumnName);
dictValuesOfCurrentColumn.Add(oCellValue, oReferencedID);
bExists = true;
break;
}
}
}
if (bExists)//有效的依赖项
{
if (!Reflection.DynamicReflectionHandler.SetProperty(oInstance.Entity, columnItem.ColumnName, oReferencedID))
{
throw new ETCLException(400, string.Format("反射方法设置依赖项属性失败,表:{0} 列:{1} 关联:{2}", tableItem.TableName, columnItem.ColumnName, oReferencedID));
}
}
else
{
isPass = false;
ETCLCommonResultItem resultItem = new ETCLCommonResultItem();
resultItem.ColumnOrder = tableItem.Columns.IndexOf(columnItem);
resultItem.Message = string.Format("[数据项:【{0}】]的数据在关联表中不存在.", columnItem.ColumnText);
resultItem.OPType = OperationType.ForeignKeyDependence;
resultItem.ResultCode = 102;
resultItem.RowIndex = tableItem.Data.Rows.IndexOf(tableRowItem);
resultItem.TableIndex = this._workSheetInfo.Tables.IndexOf(tableItem);
resultItem.WorksheetIndex = this._workSheetInfo.Index.Value;// etclInfo.WorkSheets.IndexOf(worksheetItem);
lstCheckResult.Add(resultItem);
}
}
else
{
if (oCellValue != null)
{
if (columnItem.ValueCountCache.ContainsKey(oCellValue))
{
columnItem.ValueCountCache[oCellValue]++;
}
else
{
columnItem.ValueCountCache.Add(oCellValue, 1);
}
}
if (!Reflection.DynamicReflectionHandler.SetProperty(oInstance.Entity, columnItem.ColumnName, oCellValue))
{
throw new ETCLException(400, string.Format("反射方法设置属性失败,表:{0} 列:{1} 值:{2}", tableItem.TableName, columnItem.ColumnName, oCellValue));
}
}
}
lstEntity.Add(oInstance);
}
tableItem.Entities = lstEntity;
}
oCheckResult = lstCheckResult.ToArray();
oData = lstDataItem.ToArray();
return(isPass);
}
/// <summary>
/// 构造器
/// </summary>
/// <param name="pUserInfo">用户信息</param>
/// <param name="pETCLTable">ETCL表</param>
/// <param name="pETCLColumn">ETCL列</param>
public DefaultDuplicateChecker(BasicUserInfo pUserInfo, ETCLTable pETCLTable, ETCLColumn pETCLColumn)
{
this._userInfo = pUserInfo;
this._etclTable = pETCLTable;
this._etclColumn = pETCLColumn;
}
