public override void Execute(DTObject dto)
{
var entities = dto.FindEntities(_findExp, false);
foreach (var e in entities)
{
e.Name = _name;
}
//dto.OrderEntities();
}
private void RemoveEntities(DTObject dto, string findExp)
{
var targets = dto.FindEntities(findExp, false);
foreach (var target in targets)
{
var parent = target.Parent;
if (parent == null)
{
throw new DTOException("预期之外的错误，" + findExp);
}
parent.DeletEntity(target);
}
}
private void RetainEntities(DTObject dto, string[] findExps)
{
if (findExps.Length == 0)
{
return;
}
//收集需要保留的实体
var targets = new List <ReservedInfo>();
foreach (var findExp in findExps)
{
var items = dto.FindEntities(findExp, false);
foreach (var item in items)
{
targets.Add(new ReservedInfo(item, true));
//加入自身
//再加入父亲，由于自身需要保留，所以父亲也得保留
var parent = item.Parent;
while (parent != null)
{
targets.Add(new ReservedInfo(parent, false));
parent = parent.Parent;
}
}
}
targets = targets.Distinct().ToList(); //过滤重复
var removes = new List <DTEntity>();
CollectNeedRemove(dto.GetRoot().GetEntities(), targets, removes);
foreach (var t in removes)
{
var parent = t.Parent;
if (parent == null)
{
throw new DTOException("预期之外的错误，" + string.Join(";", findExps));
}
parent.DeletEntity(t);
}
}
/// <summary>
/// 该方法用于更改成员的值
/// </summary>
/// <param name="dto"></param>
/// <param name="findExp"></param>
/// <param name="valueFindExp"></param>
/// <param name="transformValue"></param>
public void ChangeValue(DTObject dto, string findExp, string valueFindExp, Func <object, object> transformValue)
{
ArgumentAssert.IsNotNullOrEmpty(findExp, "findExp");
ArgumentAssert.IsNotNullOrEmpty(valueFindExp, "valueFindExp");
//1.找出需要赋值的目标成员
var targets = dto.FindEntities(findExp, false);
if (targets.Length == 0)
{
dto.SetValue(findExp, string.Empty); //如果没有成员，就自动生成
}
targets = dto.FindEntities(findExp, false);
var valueExpression = _getValueExpression(valueFindExp);
foreach (var target in targets)
{
var parent = target.Parent as DTEObject;
if (parent == null)
{
throw new DTOException("预期之外的错误，" + valueExpression.FindExp);
}
var parentDTO = valueExpression.StartRoot ? dto : DTOPool.CreateObject(parent, dto.IsReadOnly, dto.IsPinned);
//2.找出值，值是在目标成员所在的对象下进行查找的
var entities = parentDTO.FindEntities(valueExpression.FindExp, false);
if (entities.Length == 1)
{
//获取值
var ve = entities[0];
var newValue = GetValue(ve, transformValue, dto.IsReadOnly);
if (newValue == null)
{
throw new DTOException("预期之外的数据转换，" + valueExpression.FindExp);
}
//目标值是唯一的，这个时候要进一步判断
var valueObjParent = ve.Parent.Parent as DTEList; //这是值所在的对象的父亲
//if (valueObjFather != null && ve!=target) //如果值所在的对象处在集合中，并且不是自身对自身赋值，那么还是要以集合形式赋值
if (valueObjParent != null && ve.Parent != target.Parent) //如果值所在的对象处在集合中，并且不是自身对象对自身对象赋值，那么还是要以集合形式赋值
{
//以集合赋值
SetValue(target, new object[] { newValue }, valueExpression.FindExp);
}
else
{
//赋单值
SetValue(target, newValue, valueExpression.FindExp);
}
}
else if (entities.Length > 1)
{
//如果目标值是多个，那么是集合类型，这时候需要收集所有转换后的值，再赋值
List <object> values = new List <object>(entities.Length);
foreach (var e in entities)
{
var newValue = GetValue(e, transformValue, dto.IsReadOnly);
if (newValue == null)
{
throw new DTOException("预期之外的数据转换，" + valueExpression.FindExp);
}
values.Add(newValue);
}
SetValue(target, values, valueExpression.FindExp);
}
else
{
//值为0,需要判断是否为数组
}
}
}