/// <summary> /// This method will be called after the "CanRead" method returns TRUE. It should be responsible for returning a list of ComplexItem. Each ComplexItem represents an element in the expression. /// </summary> /// <param name="factory">Factory instance that can help in reading</param> /// <param name="expression">Expression instance to be used in ComplexItem constructor</param> /// <param name="entity">Real entity</param> /// <returns>Returns the children of the current entity</returns> public IEnumerable <ComplexEntity> GetChildren(ComplexExpressionFactory factory, Expression <object> expression, object entity) { var dyn = (System.Collections.IEnumerable)entity; foreach (KeyValuePair <string, object> item in dyn) { yield return(new DynamicItemEntity(expression, item.Key, item.Value)); } }
/// <summary> /// This method will be called to retrieve the members (Properties and Fields) of a given entity /// </summary> /// <param name="factory">Factory instance that can help in reading</param> /// <param name="expression">Expression instance to be used in ComplexItem constructor</param> /// <param name="entity">Real entity</param> /// <returns>Returns the members of the entity</returns> public IEnumerable <ComplexEntity> GetMembers(ComplexExpressionFactory factory, Expression <object> expression, object entity) { var fields = factory.GetFields(entity); foreach (var f in fields) { yield return(new FieldEntity(expression, entity, f)); } }
/// <summary> /// This method will be called after the "CanRead" method returns TRUE. It should be responsible for returning a list of ComplexItem. Each ComplexItem represents an element in the expression. /// </summary> /// <param name="factory">Factory instance that can help in reading</param> /// <param name="expression">Expression instance to be used in ComplexItem constructor</param> /// <param name="entity">Real entity</param> /// <returns>Returns the children of the current entity</returns> public IEnumerable <ComplexEntity> GetChildren(ComplexExpressionFactory factory, Expression <object> expression, object entity) { // read members foreach (var memberReader in factory.MemberReaders) { var items = memberReader.GetMembers(factory, expression, entity); foreach (var item in items) { yield return(item); } } }
/// <summary> /// This method will be called to retrieve the members (Properties and Fields) of a given entity /// </summary> /// <param name="factory">Factory instance that can help in reading</param> /// <param name="expression">Expression instance to be used in ComplexItem constructor</param> /// <param name="entity">Real entity</param> /// <returns>Returns the members of the entity</returns> public IEnumerable <ComplexEntity> GetMembers(ComplexExpressionFactory factory, Expression <object> expression, object entity) { // get all propertis: // 1) ignore indexed (this[...]) with GetIndexParameters > 0 // 2) ignore properties with only setters var properties = factory.GetProperties(entity); foreach (var p in properties) { if (!p.GetIndexParameters().Any() && p.GetGetMethod() != null) { yield return(new PropertyEntity(expression, entity, p)); } } }
/// <summary> /// This method will be called after the "CanRead" method returns TRUE. It should be responsible for returning a list of ComplexItem. Each ComplexItem represents an element in the expression. /// </summary> /// <param name="factory">Factory instance that can help in reading</param> /// <param name="expression">Expression instance to be used in ComplexItem constructor</param> /// <param name="entity">Real entity</param> /// <returns>Returns the children of the current entity</returns> public IEnumerable <ComplexEntity> GetChildren(ComplexExpressionFactory factory, Expression <object> expression, object entity) { var arrayList = (Array)entity; var list = new List <ArrayItemEntity>(); ReflectionUtils.IterateArrayMultidimensional(arrayList, indices => { list.Add(new ArrayItemEntity(expression, indices, arrayList.GetValue(indices))); }); foreach (var i in list) { yield return(i); } }
/// <summary> /// This method will be called after the "CanRead" method returns TRUE. It should be responsible for returning a list of ComplexItem. Each ComplexItem represents an element in the expression. /// </summary> /// <param name="factory">Factory instance that can help in reading</param> /// <param name="expression">Expression instance to be used in ComplexItem constructor</param> /// <param name="entity">Real entity</param> /// <returns>Returns the children of the current entity</returns> public IEnumerable <ComplexEntity> GetChildren(ComplexExpressionFactory factory, Expression <object> expression, object entity) { if (entity is IDictionary dic) { var count = 0; foreach (DictionaryEntry entry in dic) { yield return(new CollectionItemEntity(expression, count++, entry)); } // read members, it may happen to be an instance of the // user that inherits from IDictionary, so you need to read the members. foreach (var memberReader in factory.MemberReaders) { var items = memberReader.GetMembers(factory, expression, entity); foreach (var item in items) { // Ignore property "Values|Keys" because the values already specify if (item is PropertyEntity property && (property.Property.Name == "Values" || property.Property.Name == "Keys")) { continue; } yield return(item); } } } else if (entity is DictionaryEntry entry) { // Read properties: "Key" and "Value" foreach (var memberReader in factory.MemberReaders) { var items = memberReader.GetMembers(factory, expression, entity); foreach (var item in items) { yield return(item); } } } }
/// <summary> /// This method will be called after the "CanRead" method returns TRUE. It should be responsible for returning a list of ComplexItem. Each ComplexItem represents an element in the expression. /// </summary> /// <param name="factory">Factory instance that can help in reading</param> /// <param name="expression">Expression instance to be used in ComplexItem constructor</param> /// <param name="entity">Real entity</param> /// <returns>Returns the children of the current entity</returns> public IEnumerable <ComplexEntity> GetChildren(ComplexExpressionFactory factory, Expression <object> expression, object entity) { var list = (System.Collections.ICollection)entity; var enumerator = list.GetEnumerator(); var count = 0; while (enumerator.MoveNext()) { yield return(new CollectionItemEntity(expression, count++, enumerator.Current)); } // read members, it may happen to be an instance of the // user that inherits from IList, so you need to read the members. foreach (var memberReader in factory.MemberReaders) { var items = memberReader.GetMembers(factory, expression, entity); foreach (var item in items) { yield return(item); } } }
/// <summary> /// This method will determine if the entity can be read, if yes the "GetChildren" method will be called in sequence. /// </summary> /// <param name="factory">Factory instance that can help in reading</param> /// <param name="entity">Real entity</param> /// <returns>Return TRUE if can read</returns> public bool CanRead(ComplexExpressionFactory factory, object entity) { return(entity is System.Collections.ICollection); }
/// <summary> /// This method will determine if the entity can be read, if yes the "GetChildren" method will be called in sequence. /// </summary> /// <param name="factory">Factory instance that can help in reading</param> /// <param name="entity">Real entity</param> /// <returns>Return TRUE if can read</returns> public bool CanRead(ComplexExpressionFactory factory, object entity) { return(!ReflectionUtils.IsSystemType(entity.GetType())); }
/// <summary> /// This method will determine if the entity can be read, if yes the "GetChildren" method will be called in sequence. /// </summary> /// <param name="factory">Factory instance that can help in reading</param> /// <param name="entity">Real entity</param> /// <returns>Return TRUE if can read</returns> public bool CanRead(ComplexExpressionFactory factory, object entity) { return(entity is IDictionary || entity is DictionaryEntry); }
/// <summary> /// This method will determine if the entity can be read, if yes the "GetChildren" method will be called in sequence. /// </summary> /// <param name="factory">Factory instance that can help in reading</param> /// <param name="entity">Real entity</param> /// <returns>Return TRUE if can read</returns> public bool CanRead(ComplexExpressionFactory factory, object entity) { return(entity is Array); }
/// <summary> /// This method will determine if the entity can be read, if yes the "GetChildren" method will be called in sequence. /// </summary> /// <param name="factory">Factory instance that can help in reading</param> /// <param name="entity">Real entity</param> /// <returns>Return TRUE if can read</returns> public bool CanRead(ComplexExpressionFactory factory, object entity) { return(entity is System.Dynamic.ExpandoObject); }