private static void DoMergeSubClasses(ORMapping child, ORMapping parent, Collection <string> properties)
{
if (child.SubClasses == null)
{
child.SubClasses = new Collection <ManyToSubClassType>();
}
else
{
foreach (ManyToSubClassType subObj in child.SubClasses)
{
properties.Add(subObj.Property);
}
}
foreach (ManyToSubClassType subObj in parent.SubClasses)
{
if (!properties.Contains(subObj.Property))
{
child.SubClasses.Add(subObj.Clone());
}
}
}
private static void DoMergeObjectClasses(ORMapping child, ORMapping parent, Collection <string> properties)
{
if (child.ObjectClasses == null)
{
child.ObjectClasses = new Collection <ManyToObjectClassType>();
}
else
{
foreach (ManyToObjectClassType objClass in child.ObjectClasses)
{
properties.Add(objClass.Property);
}
}
foreach (ManyToObjectClassType objClass in parent.ObjectClasses)
{
if (!properties.Contains(objClass.Property))
{
child.ObjectClasses.Add(objClass.Clone());
}
}
}
private static void DoMergeSates(ORMapping child, ORMapping parent, Collection <string> properties)
{
if (child.States == null)
{
child.States = new Collection <OneToStateType>();
}
else
{
foreach (OneToStateType state in child.States)
{
properties.Add(state.Property);
}
}
foreach (OneToStateType state in parent.States)
{
if (!properties.Contains(state.Property))
{
child.States.Add(state.Clone());
}
}
}
private static void DoMergeDefaultValues(ORMapping child, ORMapping parent)
{
Collection <string> defValues = new Collection <string>();
if (child.DefaultValues == null)
{
child.DefaultValues = new Collection <DefaultValueType>();
}
else
{
foreach (DefaultValueType defValue in child.DefaultValues)
{
defValues.Add(defValue.Column);
}
}
foreach (DefaultValueType defValue in parent.DefaultValues)
{
if (!defValues.Contains(defValue.Column))
{
child.DefaultValues.Add(defValue.Clone());
}
}
}
/// <summary>
/// 用对象属性给DataRow中对应的字段赋值
/// </summary>
/// <param name="targetRow">需要赋值的数据行</param>
/// <param name="obj">用来赋值的对象</param>
/// <param name="colMaps">如果要使用关联类的属性来赋值，则需要提供当前数据集与类默认数据集的字段映射关系</param>
public static void SetDataRowValueFromObject(DataRow targetRow, object obj, Collection <ColumnToColumn> colMaps)
{
if (obj == null)
{
throw new ArgumentNullException();
}
if (targetRow == null)
{
throw new ArgumentNullException();
}
// 根据传入对象名创建实例
Type objType = obj.GetType();
ORMapping orm = FindORMapping(CastClassNameFromFullName(objType.FullName));
if (orm == null)
{
throw new ArgumentOutOfRangeException("未找到指定类的定义");
}
// 获取类所有Public属性
PropertyInfo[] properties = GetProperties(objType);
// 简化处理：先统一赋字段的默认值，再根据属性赋值
if (orm.DefaultValues != null)
{
foreach (DefaultValueType defVal in orm.DefaultValues)
{
if (targetRow.Table.Columns.Contains(defVal.Column))
{
targetRow[defVal.Column] = defVal.Value;
}
}
}
Dictionary <string, string> colMapDic = new Dictionary <string, string>(); // 原始表中列名－当前表中列名
if (colMaps != null)
{
foreach (ColumnToColumn colCol in colMaps)
{
if (!String.IsNullOrEmpty(colCol.SourceColumn))
{
colMapDic.Add(colCol.TargetColumn, colCol.SourceColumn);
}
}
}
// 给字段赋值
if (orm.OneOnes != null)
{
foreach (OneToOneType one in orm.OneOnes)
{
SetColumnValueFromNormal(targetRow, obj, properties, one, colMapDic);
}
}
if (orm.States != null)
{
foreach (OneToStateType state in orm.States)
{
SetColumnValueFromState(targetRow, obj, properties, state, colMapDic);
}
}
if (orm.Structures != null)
{
foreach (ManyToStructureType structure in orm.Structures)
{
SetColumnValueFromStruct(targetRow, obj, properties, structure, colMapDic);
}
}
if (orm.ObjectClasses != null)
{
foreach (ManyToObjectClassType objClass in orm.ObjectClasses)
{
SetColumnValueFromLinkObject(targetRow, obj, properties, objClass, colMapDic);
}
}
if (orm.SubClasses != null)
{
foreach (ManyToSubClassType subObj in orm.SubClasses)
{
SetColumnValueFromSubClass(targetRow, obj, properties, subObj);
}
}
}
private static void SetObjectPropertyFromDataRow(object targetObj, DataRow sourceRow, Collection <ColumnToColumn> colMaps)
{
try
{
if (targetObj == null)
{
return;
}
Type objType = targetObj.GetType();
ORMapping orm = FindORMapping(CastClassNameFromFullName(objType.FullName));
if (orm == null)
{
throw new ArgumentOutOfRangeException("未找到指定类的定义");
}
// 获取类所有Public属性
PropertyInfo[] properties = GetProperties(objType);
// 如果有BeginInit方法则调用
MethodInfo beginInitMethod = GetMethod(objType, "BeginInit");
if (beginInitMethod != null)
{
beginInitMethod.Invoke(targetObj, null);
}
Dictionary <string, ColumnToColumn> colMapDic = new Dictionary <string, ColumnToColumn>(); // 原始表中列名－当前表中列名
if (colMaps != null)
{
for (int i = 0; i < colMaps.Count; i++)
{
if (!colMapDic.ContainsKey(colMaps[i].TargetColumn))//先判断是否添加了相同的KEY
{
colMapDic.Add(colMaps[i].TargetColumn, colMaps[i]);
}
}
}
// 给属性赋值
if (orm.OneOnes != null)
{
foreach (OneToOneType oneOne in orm.OneOnes)
{
SetPropertyValueOfNormal(targetObj, properties, sourceRow, oneOne, colMapDic);
}
}
if (orm.States != null)
{
foreach (OneToStateType state in orm.States)
{
SetPropertyValueOfState(targetObj, properties, sourceRow, state, colMapDic);
}
}
if (orm.Structures != null)
{
foreach (ManyToStructureType structure in orm.Structures)
{
SetPropertyValueOfStruct(targetObj, properties, sourceRow, structure, colMapDic);
}
}
if (orm.ObjectClasses != null)
{
foreach (ManyToObjectClassType objClass in orm.ObjectClasses)
{
SetPropertyValueOfLinkObject(targetObj, properties, sourceRow, objClass, colMapDic);
}
}
if (orm.SubClasses != null)
{
foreach (ManyToSubClassType subObj in orm.SubClasses)
{
SetPropertyValueOfSubClass(targetObj, properties, sourceRow, subObj);
}
}
// 如果有EndInit方法则调用
MethodInfo endInitMethod = GetMethod(objType, "EndInit");
if (endInitMethod != null)
{
endInitMethod.Invoke(targetObj, null);
}
}
catch (Exception ex)
{
//MessageBox.Show("SetObjectPropertyFromDataRow方法出错：" + ex.Message);
//throw;
}
}