private object GetValue(DTEntity e, Func <object, object> transformValue, bool isReadOnly)
{
var ve = e as DTEValue;
if (ve != null)
{
return(transformValue(ve.Value));
}
var le = e as DTEList;
if (le != null)
{
var list = le.GetObjects();
var value = list.Select((item) =>
{
if (item.IsSingleValue)
{
return(item.GetValue());
}
return(item);
}).ToArray();
return(transformValue(value));
}
var oe = e as DTEObject;
if (oe != null)
{
var value = DTOPool.CreateObject(oe, isReadOnly, oe.IsPinned);
return(transformValue(value));
}
return(null);
}
public DTObject GetObject(string findExp, DTObject defaultValue)
{
var entity = this.FindEntity <DTEObject>(findExp, false);
if (entity == null)
{
return(defaultValue);
}
return(DTOPool.CreateObject(entity, this.IsReadOnly, this.IsPinned));
}
public DTObject GetObject(string findExp, bool throwError)
{
var entity = this.FindEntity <DTEObject>(findExp, throwError);
if (entity == null)
{
return(null);
}
return(DTOPool.CreateObject(entity, this.IsReadOnly, this.IsPinned));
}
private static DTObject CreateDTObject(DTEntity root, bool isReadOnly, bool isPinned)
{
var o = root as DTEObject;
if (o != null) return DTOPool.CreateObject(o, isReadOnly, isPinned);
var members = DTOPool.CreateDTEntities(isPinned);
members.Add(root);
o = DTOPool.CreateDTEObject(members, isPinned);
return DTOPool.CreateObject(o, isReadOnly, isPinned);
}
public object GetValue(string findExp, bool throwError)
{
DTEntity entity = FindEntity(findExp, throwError);
if (entity == null)
{
return(null);
}
switch (entity.Type)
{
case DTEntityType.Value:
{
var ev = entity as DTEValue;
if (ev != null)
{
return(ev.Value);
}
}
break;
case DTEntityType.Object:
{
var eo = entity as DTEObject;
if (eo != null)
{
return(DTOPool.CreateObject(eo, this.IsReadOnly, this.IsPinned));
}
}
break;
case DTEntityType.List:
{
var el = entity as DTEList;
if (el != null)
{
return(el.GetObjects());
}
}
break;
}
return(null);
}
//public Dictionary<string, T> GetDictionary<T>()
//{
// return GetDictionary<T>(string.Empty, false);
//}
//public Dictionary<string, T> GetDictionary<T>(string findExp)
//{
// return GetDictionary<T>(findExp, false);
//}
///// <summary>
///// 本质上来说,json就是一组键值对，因此可以获取键值对形式的值
///// </summary>
///// <typeparam name="T"></typeparam>
///// <param name="findExp"></param>
///// <param name="throwError"></param>
///// <returns></returns>
//public Dictionary<string, T> GetDictionary<T>(string findExp, bool throwError)
//{
// var entities = this.FindEntities(findExp, throwError);
// var dictionary = new Dictionary<string, T>(entities.Length);
// foreach (var entity in entities)
// {
// var key = entity.Name;
// var value = CreateEntityValue(entity);
// if (value is T)
// dictionary.Add(key, (T)value);
// }
// return dictionary;
//}
private object CreateEntityValue(DTEntity entity)
{
switch (entity.Type)
{
case DTEntityType.Value:
{
var temp = entity as DTEValue;
if (temp != null)
{
return(temp.Value);
}
}
break;
case DTEntityType.Object:
{
var temp = entity as DTEObject;
if (temp != null)
{
return(DTOPool.CreateObject(temp, this.IsReadOnly, this.IsPinned));
}
}
break;
case DTEntityType.List:
{
var temp = entity as DTEList;
if (temp != null)
{
return(temp.GetObjects());
}
}
break;
}
throw new DTOException("在CreateEntityValue发生未知的错误,entity类型为" + entity.GetType());
}
private object GetValue(DTEntity entity)
{
switch (entity.Type)
{
case DTEntityType.Value:
{
var ev = entity as DTEValue;
if (ev != null)
{
return(ev.Value);
}
}
break;
case DTEntityType.Object:
{
var eo = entity as DTEObject;
if (eo != null)
{
return(DTOPool.CreateObject(eo, this.IsReadOnly, this.IsPinned));
}
}
break;
case DTEntityType.List:
{
var el = entity as DTEList;
if (el != null)
{
return(el.GetObjects());
}
}
break;
}
return(null);
}
/// <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,需要判断是否为数组
}
}
}
/// <summary>
/// 完整的创建方法
/// </summary>
/// <param name="code"></param>
/// <param name="isReadOnly"></param>
/// <param name="isPinned"></param>
/// <returns></returns>
private static DTObject CreateComplete(string code, bool isReadOnly, bool isPinned)
{
var root = EntityDeserializer.Deserialize(code, isReadOnly, isPinned);
return(DTOPool.CreateObject(root, isReadOnly, isPinned));
}
public DTObject Clone()
{
return(DTOPool.CreateObject(_root.Clone() as DTEObject, this.IsReadOnly, this.IsPinned));
}