private bool validateType(JsonWriter writer, WSParam xParam, object obj, List <Type> printedTypes, bool ignoreCurcularity, WSRequest Request, MetaFunctions CFunc) { bool isValid = false; if (obj != null && Request.Security != null && Request.Security.IsValid && xParam != null) { byte uRole = Request.Security.IsLogged ? Request.Security.AuthToken.User.role : WSConstants.ACCESS_LEVEL.READ; int paramAccessLevel = xParam.READ_ACCESS_MODE.ACCESS_LEVEL; WSTableSource xSource = (WSTableSource)CFunc.GetSourceByType(obj.GetType()); paramAccessLevel = (xSource != null && xSource.AccessLevel > paramAccessLevel) ? xSource.AccessLevel : paramAccessLevel; bool showCycledTypesMessage = uRole >= WSConstants.ACCESS_LEVEL.ADMIN && xSource != null && xSource.ShowMessageInaccessible; Type entityType = null; if (obj.IsCollection()) { if (obj.IsCollectionOf <WSEntity>()) { entityType = (obj as IList).GetEntityType(); } else if (obj.IsCollectionOf <WSRecord>() && (obj as IList).Count > 0) { entityType = ((WSRecord)(obj as IList)[0]).entity.GetType(); } } else if (obj is WSRecord) { entityType = ((WSRecord)obj).entity.GetType(); } else if (obj is WSEntity) { entityType = obj.GetType(); } bool Ignore = ignoreCurcularity ? false : (printedTypes != null && printedTypes.Any(t => t == entityType)); if (Ignore) { if (showCycledTypesMessage) { WritePropName(writer, xParam.NAME); writer.WriteValue("[unavailable : cycled references detected]"); } } else { if (entityType.IsValidDynamicEntity()) { WSSource src = CFunc.GetSourceByType(entityType); isValid = src != null && uRole >= src.AccessLevel; } else { isValid = true; } } } return(isValid); }
public WSSource getSource(MetaFunctions CFunc) { if (_xSource == null) { _xSource = CFunc.GetSourceByType(GetType()); } return(_xSource); }
private object getMemberValue(WSEntity entity, WSParam eParam, MetaFunctions CFunc) { WSTableSource xSource = (WSTableSource)CFunc.GetSourceByType(entity.GetType()); IEnumerable <MemberInfo> eMembers = xSource.ReturnType.GetMembers().Where(m => m is PropertyInfo || m is FieldInfo); MemberInfo eField = eMembers.FirstOrDefault(m => eParam.Match(m.Name)); return(eField is PropertyInfo ? ((PropertyInfo)eField).GetValue(entity, null) : eField is FieldInfo ? ((FieldInfo)eField).GetValue(entity) : null); }
private dynamic readPrimitive(MetaFunctions CFunc, WSJValue jVal, WSDynamicEntity _entity) { try { if (_entity != null) { Type eType = _entity.GetType(); WSTableSource src = ((WSTableSource)CFunc.GetSourceByType(eType)); WSTableParam param = src.DBParams.FirstOrDefault(p => p.Match(jVal.Value)); PropertyInfo pInfo = eType.GetProperties().FirstOrDefault(p => p.Name.Equals(param.WSColumnRef.NAME)); return(pInfo.GetValue(_entity, null)); } } catch (Exception e) { WSStatus status = WSStatus.NONE.clone(); CFunc.RegError(GetType(), e, ref status, $"readPrimitive():373"); } return(null); }
private string LoadJson() { StringBuilder sb = new StringBuilder(); sb.Append("\"Name\":\"" + ReturnType.Name + "\""); sb.Append(",\"ReturnType\":\"" + ReturnType.FullName + "\""); sb.Append(",\"SecurityZone\":\"" + SecurityZone + "\""); sb.Append("," + base.Json); sb.Append(",\"Params\":["); Func <WSParam, bool> isAccessibleParam = x => x.READ_ACCESS_MODE.ACCESS_LEVEL <= UserRole; Func <WSParam, string> jFunc = (x => "{" + (x is WSTableParam ? ((WSTableParam)x).Json : x.Json) + "}"); if (Params != null && Params.Any(isAccessibleParam)) { List <string> paramList = new List <string>(); foreach (WSParam param in Params.Where(isAccessibleParam)) { if (param is WSTableParam) { WSTableParam tParam = (WSTableParam)param; if (tParam.IsAssociation) { WSSource src = CFunc.GetSourceByType(tParam.DataType.GetEntityType()); if (src != null && src.AccessLevel <= UserRole) { paramList.Add("{" + tParam.Json + "}"); } } else { paramList.Add("{" + tParam.Json + "}"); } } else { paramList.Add("{" + param.Json + "}"); } } sb.Append(paramList.Aggregate((a, b) => a + "," + b)); } sb.Append("]"); return(sb.ToString()); }
public override WSFilter GetOptionFilter(MetaFunctions CFunc, Expression parent, int level, string state = null, bool?negate = null) { try { if (Value.IsTrue() || Value.IsFalse()) { return(new WSBoolOFilter(this)); } else if (WSConstants.SPECIAL_CASES.Any(x => x.Match(Value))) { state = Value; if (parent.Type.IsSameOrSubclassOf(typeof(WSEntity)) || parent.Type.IsCollectionOf <WSEntity>()) { WSTableSource Source = (WSTableSource)CFunc.GetSourceByType/*<WSTableSource>*/ (parent.Type); if (parent.Type.IsSameOrSubclassOf(typeof(WSEntity)) && WSEntityFFilter.OPERATIONS.STATE_OPERATIONS.Any(x => x.Match(state))) { return(new WSEntityFilter(Source, parent, WSEntityFFilter.OPERATIONS.STATE_OPERATIONS.FirstOrDefault(x => x.Match(state)))); } } } } catch (Exception e) { WSStatus status = WSStatus.NONE.clone(); CFunc.RegError(GetType(), e, ref status); } return(null); }
public override WSFilter GetOptionFilter(MetaFunctions CFunc, Expression parent, int level, string state = null, bool?negate = null) { WSCombineFilter filter = new WSCombineFilter(WSCombineFilter.SQLMode.AndAlso); try { if (Value != null) { if (WSConstants.ALIACES.NOT.Match(Key)) { return(Value.GetOptionFilter(CFunc, parent, level, state, true)); } else if (WSConstants.ALIACES.ANY.Match(Key)) { return(Value.GetOptionFilter(CFunc, parent, level, Key, true)); } else { if (Value is WSJValue) { filter.Save(((WSJValue)Value).GetOptionFilter(CFunc, parent, level, state, negate)); } else { WSTableSource PSource = (WSTableSource)CFunc.GetSourceByType(parent.Type.GetEntityType()); WSTableParam subParam = PSource == null ? null : (WSTableParam)PSource.GetXParam(Key); //TODO@ANDVO:2016-11-15: implement deep filtering } return(filter.Any() ? (filter.Count == 1 && !filter.Negate) ? filter.FirstOrDefault() : filter : null); } } } catch (Exception e) { WSStatus status = WSStatus.NONE.clone(); CFunc.RegError(GetType(), e, ref status); } return(null); }
public WSStatus WriteJson(JsonWriter writer, JsonSerializer serializer, WSSchema schema, WSParamList outFields, List <Type> printedTypes, WSRequest Request, MetaFunctions CFunc, WSDataContext DBContext) { WSStatus status = WSStatus.NONE_Copy(); WSEntitySchema eSchema = null; WSSource xSource = CFunc.GetSourceByType(GetType()); if (schema != null && schema is WSEntityBaseSchema) { if (schema is WSEntitySchema) { eSchema = (WSEntitySchema)schema; } else if (schema is WSEntityListSchema) { eSchema = ((WSEntityListSchema)schema).EntitySchema; } } if (eSchema == null && this is WSDynamicEntity) { if (xSource != null && xSource is WSTableSource && ((WSTableSource)xSource).BaseSchema != null) { eSchema = ((WSTableSource)xSource).BaseSchema; } } #region Read if in 'COLLAPSED' mode bool collapsedMode = false; if (eSchema != null) { IEnumerable <WSJObject> _JOptions = eSchema.IOBaseOptions.Value.OfType <WSJObject>(); Func <WSJProperty, bool> func = v => WSConstants.ALIACES.OPTION_COLLECT.Match(v.Key); WSJObject takeJOption = _JOptions.FirstOrDefault(x => x.Value.Any(func)); if (takeJOption != null && takeJOption.IsValid) { collapsedMode = true; status.childs.Add(WriteCollapsedValues(writer, serializer, this, xSource, takeJOption.Value.FirstOrDefault(func).Value, Request, CFunc)); } } #endregion if (!collapsedMode) { writer.WriteStartObject(); if (this is WSStaticEntity || (eSchema != null && eSchema.Fields.Any())) { List <Type> postPrintedTypes = printedTypes.Select(x => x).ToList(); if (!postPrintedTypes.Any(x => x == GetType())) { postPrintedTypes.Add(GetType()); } status.childs.Add( WriteJMembers( GetType().GetMembers(BindingFlags.Public | BindingFlags.Instance).Where(m => m is PropertyInfo || m is FieldInfo), writer, serializer, eSchema, xSource, outFields, printedTypes, Request, CFunc, DBContext ) ); } writer.WriteEndObject(); } return(status); }
private WSStatus WriteCollapsedValues(JsonWriter writer, JsonSerializer serializer, WSEntity entity, WSSource xSource, WSJson collapseOption, WSRequest Request, MetaFunctions CFunc) { WSStatus status = WSStatus.NONE_Copy(); try { /******************************************************************************* * * // TODO @ANDVO : 2016-02-15 : IMPORTANT!!! => Implement security check like this : * * WSStatus status = Validate(obj, xParam, writer, serializer, security, schema); * if (status.CODE == WSStatus.SUCCESS.CODE) * { */ if (entity != null && collapseOption != null && collapseOption.IsValid) { WSTableSource childSource = (WSTableSource)CFunc.GetSourceByType(entity.GetType()); object fieldValue = null; WSParam field = null; if (collapseOption is WSJValue) { string fieldName = ((WSJValue)collapseOption).Value; field = entity.GetParam(xSource, fieldName); fieldValue = getMemberValue(entity, field, CFunc); WSPrimitiveFieldSchema fieldSchema = new WSPrimitiveFieldSchema(CFunc, (WSTableParam)field, new WSJProperty(fieldName, new WSJArray()), /*((WSTableSource)entity.getSource())*/ childSource.BaseSchema); if (Validate(fieldValue, field, writer, serializer, childSource.BaseSchema, childSource, null, ref status, Request, CFunc)) { object _obj = null; serializer.Serialize(writer, field.TryReadPrimitiveWithDefault(fieldValue, string.Empty, out _obj) ? _obj : string.Empty); writer.Flush(); status = WSStatus.SUCCESS_Copy(); } } else if (collapseOption is WSJObject) { WSJProperty collapseSrc = ((WSJObject)collapseOption).Value.FirstOrDefault(); field = entity.GetParam(childSource, collapseSrc.Key); fieldValue = getMemberValue(entity, field, CFunc); if (Validate(fieldValue, field, writer, serializer, childSource.BaseSchema, childSource, null, ref status, Request, CFunc)) { if (fieldValue == null) { serializer.Serialize(writer, "NULL"); writer.Flush(); } else if (fieldValue is WSEntity) { WSTableSource fieldSource = (WSTableSource)CFunc.GetSourceByType(fieldValue.GetType()); status = WriteCollapsedValues(writer, serializer, (WSEntity)fieldValue, fieldSource, collapseSrc.Value, Request, CFunc); } else if (fieldValue.IsCollectionOf <WSEntity>()) { WSTableSource fieldSource = (WSTableSource)CFunc.GetSourceByType(fieldValue.GetType().GetEntityType()); if (!((IEnumerable <WSEntity>)fieldValue).Any()) { serializer.Serialize(writer, "NULL"); writer.Flush(); } else { foreach (WSEntity eItem in (IEnumerable <WSEntity>)fieldValue) { status.childs.Add(WriteCollapsedValues(writer, serializer, eItem, fieldSource, collapseSrc.Value, Request, CFunc)); } status = status.IsPositive ? WSStatus.SUCCESS_Copy() : WSStatus.ERROR_Copy(); } } } } } /*} * *******************************************************************************/ } catch (Exception e) { CFunc.RegError(GetType(), e, ref status); } return(status); }
public virtual bool Match(string key, IEnumerable <WSTableSource> sources = null, Func <Type, WSTableSource> getTSource = null, bool TypeMatchAllowed = true) { try { if (!string.IsNullOrEmpty(NAME) && !string.IsNullOrEmpty(key)) { key = key.ToLower(); int _CODE = -1; if (CODE >= 0) { if (NAME.Equals(key)) { return(true); } else if (DISPLAY_NAME.Equals(key)) { return(true); } else if (ALIACES != null && ALIACES.Contains(key)) { return(true); } else if (this is WSTableParam) { WSTableParam p = (WSTableParam)this; if (p.WSColumnRef.NAME.ToLower().Equals(key)) { return(true); } else if (TypeMatchAllowed && p.DataType.IsValidDynamicEntity()) { WSTableSource src = null; if (getTSource != null) { src = getTSource(p.DataType.GetEntityType()); } else if (sources != null) { src = sources.FirstOrDefault(s => s.ReturnType == p.DataType.GetEntityType()); } else if (func != null) { src = (WSTableSource)func.GetSourceByType(p.DataType.GetEntityType()); } if (src != null && src.Match(key)) { return(true); } } } else if (int.TryParse(key, out _CODE) && _CODE == CODE) { return(true); } } ; } } catch (Exception) { } return(false); }
public override Expression SortTable <TEntity>(MetaFunctions CFunc, WSDataContext dc, List <PropertyInfo> parents, Expression expression, ref WSStatus iostatus) { try { if (dc != null) { parents = parents != null ? parents : new List <PropertyInfo>(); Type srcType = parents.Any() ? parents.LastOrDefault().PropertyType.IsCollection() ? parents.LastOrDefault().PropertyType.GetEntityType() : parents.LastOrDefault().PropertyType : typeof(TEntity); ITable initSource = srcType == null ? null : dc.GetTable(typeof(TEntity)); ITable source = srcType == null ? null : dc.GetTable(srcType); WSTableSource schema = srcType == null ? null : (WSTableSource)CFunc.GetSourceByType(srcType); if (schema != null) { WSParam param = schema.GetXParam(Value); if (param != null && param is WSTableParam) { WSTableParam tParam = (WSTableParam)param; PropertyInfo property = srcType.GetProperties().FirstOrDefault(p => tParam.WSColumnRef.NAME.Equals(p.Name)); if (property == null) { iostatus.AddNote(string.Format("No PropertyInfo found for : [{0}]", tParam.DISPLAY_NAME)); } else { parents.Add(property); if (tParam.DataType.IsSimple() && tParam.IsSortable) { expression = SortPrimitiveType <TEntity>(initSource, source, param, false, parents, expression, ref iostatus); } } } } } } catch (Exception e) { WSStatus status = WSStatus.NONE.clone(); CFunc.RegError(GetType(), e, ref status); } return(expression); }
public override WSFilter GetFieldFilter(MetaFunctions CFunc, WSTableParam param, Expression parent, int level, string state = null, bool?negate = null) { WSCombineFilter filter = new WSCombineFilter(WSCombineFilter.SQLMode.AndAlso); try { if (param != null && param.isValid && (param.DataType.IsNullable() || Value != null)) { if (param.DataType.IsSimple()) { bool localNegate = WSConstants.ALIACES.NOT.Match(state); negate = negate == null ? localNegate : localNegate != negate; WSFilter pFilter = Value.GetFieldFilter(CFunc, param, parent, level, Key, negate); filter.Save(pFilter); } else if (param.DataType.IsSameOrSubclassOf(typeof(WSEntity)) || param.DataType.IsCollectionOf <WSEntity>()) { if (WSConstants.ALIACES.NOT.Match(Key)) { return(Value.GetFieldFilter(CFunc, param, parent, level, state, true)); } else if (WSConstants.ALIACES.ANY.Match(Key)) { return(Value.GetFieldFilter(CFunc, param, parent, level, Key, true)); } else { WSTableSource PSource = (WSTableSource)CFunc.GetSourceByType/*<WSTableSource>*/ (param.DataType.GetEntityType()); WSTableParam subParam = PSource == null ? null : (WSTableParam)PSource.GetXParam(Key); Expression member = Expression.Property(parent, param.WSColumnRef.NAME); if (subParam == null && WSConstants.SPECIAL_CASES.Any(c => c.Match(Key))) { if (param.DataType.IsSameOrSubclassOf(typeof(WSEntity))) { return(new WSEntityFFilter(param, member, WSEntityFFilter.OPERATIONS.STATE_OPERATIONS.FirstOrDefault(x => x.Match(Key))) { Value = null }); } else if (param.DataType.IsCollectionOf <WSEntity>()) { return(new WSEntityListFFilter(param, member, WSEntityListFFilter.OPERATIONS.STATE_OPERATIONS.FirstOrDefault(x => x.Match(Key))) { Value = null }); } } else { WSFilter subFilter = null; if (param.DataType.IsSameOrSubclassOf(typeof(WSEntity))) { filter.Save(new WSEntityFFilter(param, member, WSEntityFFilter.OPERATIONS.NotEqual) { Value = null }); subFilter = Value.GetFieldFilter(CFunc, subParam, member, level, Key); if (subFilter != null && subFilter.IsValid) { filter.Save(new WSEntityFFilter(param, member, WSEntityFFilter.OPERATIONS.Filter) { Value = subFilter }); } } else if (param.DataType.IsCollectionOf <WSEntity>()) { level++; Type elemType = param.DataType.GetEntityType(); ParameterExpression id = Expression.Parameter(elemType, level.ToHex()); subFilter = Value.GetFieldFilter(CFunc, subParam, id, level, Key, negate); if (subFilter != null && subFilter.IsValid) { dynamic subExpr = subFilter.GetType().GetMethod("ToLambda").MakeGenericMethod(new Type[] { elemType }).Invoke(subFilter, new object[] { id }); filter.Save(new WSEntityListFFilter(subParam, member, WSEntityListFFilter.OPERATIONS.Any) { Value = (subExpr == null) ? true : subExpr }); } } } } } } } catch (Exception e) { WSStatus status = WSStatus.NONE.clone(); CFunc.RegError(GetType(), e, ref status); } return(filter.Any() ? (filter.Count == 1 && !filter.Negate) ? filter.FirstOrDefault() : filter : null); }
public override bool MatchEntity(MetaFunctions CFunc, WSDynamicEntity entity, WSTableSource src, string key = null, string matchOperation = null) { bool isMatch = true; try { if (!IsValid) { isMatch = false; } else { if (string.IsNullOrEmpty(key)) { key = Key; } else { matchOperation = Key; } if (Value is WSJValue) { isMatch = ((WSJValue)Value).MatchEntity(CFunc, entity, src, key, matchOperation); } else { if (src.DBAssociationParams.Any(p => p.Match(Key))) { WSTableParam param = src.DBAssociationParams.FirstOrDefault(p => p.Match(Key)); src = (WSTableSource)CFunc.GetSourceByType(param.DataType.GetEntityType()); object oEntity = entity.GetType().GetProperty(param.WSColumnRef.NAME).GetValue(entity, null); if (oEntity.GetType().IsCollectionOf <WSDynamicEntity>()) { foreach (WSDynamicEntity e in (IEnumerable <WSDynamicEntity>)oEntity) { if (Value is WSJObject) { if (((WSJObject)Value).MatchEntity(CFunc, e, src)) { isMatch = true; } } else if (Value is WSJArray) { if (((WSJArray)Value).MatchEntity(CFunc, e, src)) { isMatch = true; } } } } else { if (Value is WSJObject) { isMatch = ((WSJObject)Value).MatchEntity(CFunc, (WSDynamicEntity)oEntity, src); } else if (Value is WSJArray) { isMatch = ((WSJArray)Value).MatchEntity(CFunc, (WSDynamicEntity)oEntity, src); } } } else { if (Value is WSJObject) { isMatch = ((WSJObject)Value).MatchEntity(CFunc, entity, src, key); } else if (Value is WSJArray) { isMatch = ((WSJArray)Value).MatchEntity(CFunc, entity, src, key); } } } } } catch (Exception e) { isMatch = false; WSStatus status = WSStatus.NONE.clone(); CFunc.RegError(GetType(), e, ref status); } return(isMatch); }
public override bool Match(WSRequest Request, WSDataContext DBContext, MetaFunctions CFunc, WSSchema schema) { bool ok = false; try { WSEntitySchema eSchema = null; if (schema is WSEntitySchema) { eSchema = (WSEntitySchema)schema; } else if (schema is WSEntityListSchema) { eSchema = ((WSEntityListSchema)schema).EntitySchema; } if (eSchema != null) { bool baseFilterMatch = true; if (eSchema.Source.BaseFilter != null && eSchema.Source.BaseFilter.IsValid && eSchema.Source.BaseFilter.apply(Request, CFunc)) { baseFilterMatch = eSchema.Source.BaseFilter.MatchEntity(CFunc, this, ((WSTableSource)CFunc.GetSourceByType(GetType()))); } bool dynamicFilterMatch = true; if (eSchema.Fields != null || eSchema.Fields != null) { dynamicFilterMatch = MatchFields(Request, CFunc, eSchema) && MatchFilters(Request, CFunc, eSchema); } ok = baseFilterMatch && dynamicFilterMatch; } } catch (Exception e) { if (Request != null) { CFunc.RegError(GetType(), e, ref Request.status, $"Match():434"); } else { WSStatus status = WSStatus.NONE.clone(); CFunc.RegError(GetType(), e, ref status, $"Match():435"); } } return(ok); }
public bool TrySetRecordValue(string colName, object newValue, WSDataContext DBContext, MetaFunctions CFunc, Func <Exception, bool> AddError = null) { bool done = false; if (!string.IsNullOrEmpty(colName)) { PropertyInfo pInfo = GetType().GetProperty(colName); if (pInfo != null) { object orgValue = pInfo.GetValue(this, null); newValue = fixSpecialCaseValue(colName, newValue, pInfo.PropertyType); try { if ( orgValue == newValue || (orgValue == null && newValue == null) || (orgValue != null && newValue != null && orgValue.ToString().Equals(newValue.ToString())) ) { return(true); } else { if (newValue == null) { if (pInfo.PropertyType.IsNullable()) { pInfo.SetPropertyValue(this, null); done = true; } } else { object newValueConverted = pInfo.PropertyType.IsAssignableFrom(newValue.GetType()) ? newValue : null; if (newValueConverted != null || pInfo.PropertyType.Read(newValue, out newValueConverted, null, null, pInfo.Name)) { try { bool IsAssiciation = false; PropertyInfo association = null; WSTableSource associationSrc = null; WSTableParam associationKey = null; PropertyInfo[] props = GetType().GetProperties(); foreach (PropertyInfo prop in props) { IEnumerable <CustomAttributeData> cAttrs = prop.CustomAttributesData(); foreach (CustomAttributeData cad in cAttrs) { CustomAttributeNamedArgument IsForeignKey = cad.NamedArguments.FirstOrDefault(x => x.MemberInfo.Name.Equals("IsForeignKey")); if (IsForeignKey != null && IsForeignKey.TypedValue.Value != null && (true.ToString()).Equals(IsForeignKey.TypedValue.Value.ToString())) { CustomAttributeNamedArgument cana = cad.NamedArguments.FirstOrDefault(x => x.MemberInfo.Name.Equals("ThisKey")); if (cana != null && pInfo.Name.Equals(cana.TypedValue.Value == null ? null : cana.TypedValue.Value.ToString())) { CustomAttributeNamedArgument canaKey = cad.NamedArguments.FirstOrDefault(x => x.MemberInfo.Name.Equals("OtherKey")); if (canaKey != null && canaKey.TypedValue.Value != null) { IsAssiciation = true; association = prop; associationSrc = (WSTableSource)CFunc.GetSourceByType(association.PropertyType); associationKey = (WSTableParam)associationSrc.GetXParam(canaKey.TypedValue.Value.ToString()); } } } } } if (IsAssiciation) { string pName = pInfo.Name; ParameterExpression paramExp = Expression.Parameter(association.PropertyType, "x"); WSCombineFilter filter = new WSCombineFilter(WSCombineFilter.SQLMode.AndAlso); filter.Save(new WSJValue(newValueConverted.ToString()).GetFieldFilter(CFunc, associationKey, paramExp, 0)); object subExpr = (Expression)filter.GetType().GetMethod("ToLambda").MakeGenericMethod(new Type[] { association.PropertyType }).Invoke(filter, new object[] { paramExp }); MethodInfo mInfo = DBContext.GetType().GetMethod("GetTable", new Type[] { }); var tObj = mInfo.MakeGenericMethod(new Type[] { association.PropertyType }).Invoke(DBContext, new object[] { }); Func <WSDynamicEntity, bool> func = s => s.readPropertyValue(associationKey.WSColumnRef.NAME).ToString().Equals(newValueConverted.ToString()); var method = typeof(Enumerable).GetMethods(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public) .FirstOrDefault(m => m.Name == "FirstOrDefault" && m.GetParameters().Count() == 2).MakeGenericMethod(typeof(WSDynamicEntity)); WSDynamicEntity newAssociation = (WSDynamicEntity)method.Invoke(null, new object[] { tObj, func }); if (newAssociation != null) { association.SetPropertyValue(this, newAssociation); done = true; } } else { pInfo.SetPropertyValue(this, newValueConverted); done = true; } } catch (Exception e1) { AddError(e1); } } } } } catch (Exception e) { AddError(e); } if (!done) { pInfo.SetPropertyValue(this, orgValue); } } } return(done); }