/// <summary> /// extracts parameters from lambda /// </summary> /// <param name="lambdaExpression">lambda expression with where clause</param> /// <returns>dictionary of parameter name/value pairs</returns> public Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression) { return (new ParameterFinder <Trend>( lambdaExpression.Body, new List <string> { "Type", "Date", "ExcludeHashtags" }) .Parameters); }
/// <summary> /// extracts parameters from lambda /// </summary> /// <param name="lambdaExpression">lambda expression with where clause</param> /// <returns>dictionary of parameter name/value pairs</returns> public virtual Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression) { return (new ParameterFinder <Account>( lambdaExpression.Body, new List <string> { "Type", "SkipStatus", "IncludeEntities" }) .Parameters); }
/// <summary> /// Converts a LINQ lambda expression into the Infer.NET equivalent. /// </summary> /// <param name="lambdaExpression"></param> /// <returns></returns> internal ILambdaExpression ConvertLambda(System.Linq.Expressions.LambdaExpression lambdaExpression) { var lambda = new XLambdaExpression { Body = Convert(lambdaExpression.Body), }; foreach (var p in lambdaExpression.Parameters) { lambda.Parameters.Add(ConvertParameterToVar(p)); } return(lambda); }
public override void BuildSql() { if (Property == "IsNotEmpty") { if (empty == null) { empty = CreateBuilder(this.Statement.SqlContext.Context, this.Sql); } } else if (expression == null) { object obj = Statement.SqlContext.Context; expression = DynamicExpressionParser.ParseLambda(obj.GetType(), typeof(bool), this.Sql); } }
internal static DMS DMSInsertIdentity(this DMS dms, IEntity entity) { dms.ExcuteType = DMSExcuteType.INSERTIDENTITY; IDictionary <string, object> ChangedProperties = ((IEntity)entity).ChangedMappingProperties; if (ChangedProperties == null || ChangedProperties.Count == 0) { Log.Debug(ReflectionUtils.GetMethodBaseInfo(System.Reflection.MethodBase.GetCurrentMethod()), "插入字段为空,不能进行添加数据", null); throw new DMSFrameException("插入字段为空,不能进行添加数据"); } System.Linq.Expressions.ParameterExpression yExpr = System.Linq.Expressions.Expression.Parameter(entity.GetType(), "x"); System.Linq.Expressions.LambdaExpression lambdaExpr = System.Linq.Expressions.Expression.Lambda(System.Linq.Expressions.Expression.Constant(ChangedProperties), yExpr); dms.ColumnsExpressioin.Append(lambdaExpr); return(dms); }
private static MethodInfo GetMethodInfo(System.Linq.Expressions.LambdaExpression expression) { if (expression.Body is System.Linq.Expressions.MethodCallExpression method) { return(method.Method); } if (expression.Body is System.Linq.Expressions.BinaryExpression binary) { return(binary.Method); } if (expression.Body is System.Linq.Expressions.MemberExpression property) { return(((PropertyInfo)property.Member).GetGetMethod()); } throw new ArgumentException("Invalid Expression. Expression should consist of a Method call only."); }
} // End Function GetNamespaces static AccessorCache() { try { s_GetNamespaces = null; System.Linq.Expressions.ParameterExpression p = System.Linq.Expressions.Expression.Parameter(typeof(T)); System.Linq.Expressions.MemberExpression prop = System.Linq.Expressions.Expression.Property(p, "Namespaces"); System.Linq.Expressions.UnaryExpression con = System.Linq.Expressions.Expression.Convert(prop, typeof(System.Xml.Serialization.XmlSerializerNamespaces)); System.Linq.Expressions.LambdaExpression exp = System.Linq.Expressions.Expression.Lambda(con, p); s_GetNamespaces = (System.Func <T, System.Xml.Serialization.XmlSerializerNamespaces>)exp.Compile(); } catch (System.Exception ex) { System.Console.WriteLine(ex.Message); System.Console.WriteLine(ex.StackTrace); } } // End Static constructor
/// <summary> /// extracts parameters from lambda /// </summary> /// <param name="lambdaExpression">lambda expression with where clause</param> /// <returns>dictionary of parameter name/value pairs</returns> public virtual Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression) { var paramFinder = new ParameterFinder <Blocks>( lambdaExpression.Body, new List <string> { "Type", "ID", "UserID", "ScreenName", "Page" }); var parameters = paramFinder.Parameters; return(parameters); }
/// <summary> /// extracts parameters from lambda /// </summary> /// <param name="lambdaExpression">lambda expression with where clause</param> /// <returns>dictionary of parameter name/value pairs</returns> public Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression) { var paramFinder = new ParameterFinder <Search>( lambdaExpression.Body, new List <string> { "Type", "Query", "Language", "PageSize", "Page", "SinceID", "GeoCode", "ShowUser" }); return(paramFinder.Parameters); }
/// <summary> /// extracts parameters from lambda /// </summary> /// <param name="lambdaExpression">lambda expression with where clause</param> /// <returns>dictionary of parameter name/value pairs</returns> public virtual Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression) { var paramFinder = new ParameterFinder <Blocks>( lambdaExpression.Body, new List <string> { "Type", "UserID", "ScreenName", "Page", "PerPage", "IncludeEntities", "SkipStatus", "Cursor" }); return(paramFinder.Parameters); }
public static dynamic TryGetProperty(dynamic dynamicObject, String PropertyName, dynamic Default) { try { if (!HasProperty(dynamicObject, PropertyName)) { return(Default); } if (dynamicObject.GetType() == typeof(System.Web.Helpers.DynamicJsonObject)) { // good thing this type of documentation was easy to find System.Web.Helpers.DynamicJsonObject obj = (System.Web.Helpers.DynamicJsonObject)dynamicObject; Type scope = obj.GetType(); System.Dynamic.IDynamicMetaObjectProvider provider = obj as System.Dynamic.IDynamicMetaObjectProvider; if (provider != null) { System.Linq.Expressions.ParameterExpression param = System.Linq.Expressions.Expression.Parameter(typeof(object)); System.Dynamic.DynamicMetaObject mobj = provider.GetMetaObject(param); System.Dynamic.GetMemberBinder binder = (System.Dynamic.GetMemberBinder)Microsoft.CSharp.RuntimeBinder.Binder.GetMember(0, PropertyName, scope, new Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo[] { Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo.Create(0, null) }); System.Dynamic.DynamicMetaObject ret = mobj.BindGetMember(binder); System.Linq.Expressions.BlockExpression final = System.Linq.Expressions.Expression.Block( System.Linq.Expressions.Expression.Label(System.Runtime.CompilerServices.CallSiteBinder.UpdateLabel), ret.Expression ); System.Linq.Expressions.LambdaExpression lambda = System.Linq.Expressions.Expression.Lambda(final, param); Delegate del = lambda.Compile(); return(del.DynamicInvoke(obj)); } else { return(obj.GetType().GetProperty(PropertyName, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance).GetValue(obj, null)); } } else if (dynamicObject.GetType() == typeof(System.Collections.IDictionary)) { return((Dictionary <String, object>)dynamicObject[PropertyName]); } return(Default); } catch (Exception ex) { throw new Exception("Could not determine if dynamic object has property.", ex); } }
protected static MethodInfo GetStatic(LambdaExpression expression, Type expectedReturnType) { var unaryExpression = (UnaryExpression)expression.Body; var methodCallExpression = (MethodCallExpression)unaryExpression.Operand; var methodCallObject = (ConstantExpression)methodCallExpression.Object !; var method = (MethodInfo)methodCallObject.Value; if (method.IsStatic == false) { throw new ArgumentException($"Method {method.Name} should be static."); } if (method.ReturnType != expectedReturnType) { throw new ArgumentException($"Method {method.Name} should return {expectedReturnType.Name}."); } return(method); }
public static string PropertyName <TProperty>(System.Linq.Expressions.Expression <System.Func <TProperty> > property) { System.Linq.Expressions.LambdaExpression lambda = (System.Linq.Expressions.LambdaExpression)property; System.Linq.Expressions.MemberExpression memberExpression; if (lambda.Body is System.Linq.Expressions.UnaryExpression) { var unaryExpression = (System.Linq.Expressions.UnaryExpression)lambda.Body; memberExpression = (System.Linq.Expressions.MemberExpression)unaryExpression.Operand; } else { memberExpression = (System.Linq.Expressions.MemberExpression)lambda.Body; } return(memberExpression.Member.Name); }
/// <summary> /// extracts parameters from lambda /// </summary> /// <param name="lambdaExpression">lambda expression with where clause</param> /// <returns>dictionary of parameter name/value pairs</returns> public Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression) { var paramFinder = new ParameterFinder <Search>( lambdaExpression.Body, new List <string> { "Type", "Query", "GeoCode", "SearchLanguage", "Locale", "ResultType", "Count", "Until", "SinceID", "MaxID", "IncludeEntities" }); return(paramFinder.Parameters); }
private static System.Linq.Expressions.Expression GetSelector_old( string member, System.Type entityType ) { // Note: entityType = typeof(T); System.Linq.Expressions.ParameterExpression arg = System.Linq.Expressions.Expression.Parameter(entityType, "x"); System.Linq.Expressions.Expression expr = arg; System.Reflection.BindingFlags bf = System.Reflection.BindingFlags.IgnoreCase | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Static; System.Type type = null; System.Reflection.PropertyInfo pi = entityType.GetProperty(member, bf); if (pi == null) { System.Reflection.FieldInfo fi = entityType.GetField(member, bf); expr = System.Linq.Expressions.Expression.Field(expr, fi); type = fi.FieldType; } else { expr = System.Linq.Expressions.Expression.Property(expr, pi); type = pi.PropertyType; } Type delegateType = typeof(Func <,>).MakeGenericType(entityType, type); System.Linq.Expressions.LambdaExpression lambda = System.Linq.Expressions.Expression.Lambda(delegateType, expr, arg); return(lambda); }
public static IQueryable GenerateSortExpression(IQueryable source, Type sourceType, string propertyName, string action) { System.Linq.Expressions.ParameterExpression paramExpression = System.Linq.Expressions.Expression.Parameter(sourceType, sourceType.Name); System.Linq.Expressions.MemberExpression memExp = System.Linq.Expressions.Expression.PropertyOrField(paramExpression, propertyName); System.Linq.Expressions.LambdaExpression lambda = System.Linq.Expressions.Expression.Lambda(memExp, paramExpression); return(source.Provider.CreateQuery( System.Linq.Expressions.Expression.Call( typeof(Queryable), action, new Type[] { source.ElementType, lambda.Body.Type }, source.Expression, lambda))); }
// NH-specific public static void AddAll(IList to, IList from) { System.Action addNull = null; foreach (object obj in from) { // There is bug in .NET, before version 4, where adding null to a List<Nullable<T>> through the non-generic IList interface throws an exception. // TODO: Everything but the to.Add(obj) should be conditionally compiled only for versions of .NET earlier than 4. if (obj == null) { if (addNull == null) { if (to.GetType().IsGenericType&& to.GetType().GetGenericTypeDefinition() == typeof(List <>) && to.GetType().GetGenericArguments()[0].IsGenericType && to.GetType().GetGenericArguments()[0].GetGenericTypeDefinition() == typeof(Nullable <>)) { MethodInfo addMethod = to.GetType().GetMethod("Add"); System.Linq.Expressions.MethodCallExpression addMethodCall = System.Linq.Expressions.Expression.Call(System.Linq.Expressions.Expression.Constant(to), addMethod, System.Linq.Expressions.Expression.Constant(null, to.GetType().GetGenericArguments()[0])); System.Linq.Expressions.LambdaExpression addLambda = System.Linq.Expressions.Expression.Lambda(addMethodCall); addNull = (System.Action)addLambda.Compile(); } else { addNull = () => to.Add(null); } } addNull(); } else { to.Add(obj); } } }
/// <summary> /// extracts parameters from lambda /// </summary> /// <param name="lambdaExpression">lambda expression with where clause</param> /// <returns>dictionary of parameter name/value pairs</returns> public Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression) { var paramFinder = new ParameterFinder <Search>( lambdaExpression.Body, new List <string> { nameof(Type), nameof(Query), nameof(GeoCode), nameof(SearchLanguage), nameof(Locale), nameof(ResultType), nameof(Count), nameof(Until), nameof(SinceID), nameof(MaxID), nameof(IncludeEntities), nameof(TweetMode) }); return(paramFinder.Parameters); }
public override DataTemplate SelectTemplate(object item, DependencyObject container) { if (ItemType.IsInstanceOfType(item)) { if (getPropertyValue == null) { System.Linq.Expressions.ParameterExpression instanceParameter = System.Linq.Expressions.Expression.Parameter(item.GetType(), "p"); System.Linq.Expressions.MemberExpression currentExpression = System.Linq.Expressions.Expression.PropertyOrField(instanceParameter, PropertyName); System.Linq.Expressions.LambdaExpression lambdaExpression = System.Linq.Expressions.Expression.Lambda(currentExpression, instanceParameter); getPropertyValue = lambdaExpression.Compile(); } return(SelectTemplateImpl(getPropertyValue.DynamicInvoke(item), container)); } return(base.SelectTemplate(item, container)); }
protected virtual ComparisonResult CompareStructural(QueryStructuralValue expected, object actual, string path, bool shouldThrow) { this.AddToLogBuffer("Verifying structural value. Path: {0}", path); if (actual == null) { if (expected.IsNull) { return(ComparisonResult.Success); } this.ThrowOrLogError(shouldThrow, "Expecting non-null value: {0} in '{1}. Got null instead.", expected, path); return(ComparisonResult.Failure); } if (expected.IsNull) { // if expected is null but actual is non-null this can be a result of the fact that entity was present in the ObjectStateManager and got attached even though // this particular query did not bring it back. if (this.LinqResultComparerContextAdapter.IsObjectTrackedByContext(actual)) { this.AddToLogBuffer("Verifying structural value. Path: {0} SKIPPED (Entity in Object State Manager)", path); return(ComparisonResult.Skipped); } else { this.ThrowOrLogError(shouldThrow, "Expecting null value in '{0}'. Actual: {1}[{2}].", path, actual, actual.GetType()); return(ComparisonResult.Failure); } } List <object> visited; if (!this.visitedEntities.TryGetValue(expected, out visited)) { visited = new List <object>(); this.visitedEntities.Add(expected, visited); } if (visited.Contains(actual)) { this.AddToLogBuffer("Verifying structural value. Path: {0} SKIPPED (Already visited)", path); return(ComparisonResult.Skipped); } visited.Add(actual); var expectedType = expected.Type as IQueryClrType; if (expectedType != null) { ExceptionUtilities.Assert(expectedType.ClrType != null, "Expecting non-null CLR type."); if (!expectedType.ClrType.IsAssignableFrom(actual.GetType())) { this.ThrowOrLogError(shouldThrow, "Types not match in {0}. Expecting: {1}. Actual: {2}.", path, expectedType.ClrType, actual.GetType()); return(ComparisonResult.Failure); } } bool comparisonSkippedForAnyProperty = false; var properties = actual.GetType().GetProperties(); IEnumerable <string> propertyNames = expected.MemberNames; #if WIN8 bool isAnonymousType = IsAnonymousType(actual.GetType()); int i = 0; #endif foreach (string expectedName in propertyNames) { #if WIN8 // In WIN8 we are using CSharpGenericTypeBuilder. Properties have fixed names such as Field1, Field2,... var actualProperty = isAnonymousType ? properties.ToArray()[i++] : properties.Where(p => p.Name == expectedName).SingleOrDefault(); #else var actualProperty = properties.Where(p => p.Name == expectedName).SingleOrDefault(); #endif if (actualProperty == null) { this.ThrowOrLogError(shouldThrow, "Expected property not found: {0} in '{1}'.", expectedName, path); return(ComparisonResult.Failure); } object actualValue = null; #if SILVERLIGHT CoreLinq.Expressions.ParameterExpression param = CoreLinq.Expressions.Expression.Parameter(typeof(Object), "param"); CoreLinq.Expressions.Expression convertedParam = CoreLinq.Expressions.Expression.Convert(param, actual.GetType()); CoreLinq.Expressions.LambdaExpression GetPropertyValueExp = CoreLinq.Expressions.Expression.Lambda(System.Linq.Expressions.Expression.Property(convertedParam, actualProperty), param); Delegate dynamicGetter = GetPropertyValueExp.Compile(); actualValue = dynamicGetter.DynamicInvoke(actual); #else actualValue = actualProperty.GetValue(actual, null); #endif QueryType expectedPropertyType = expected.Type.Properties.Where(p => p.Name == expectedName).Single().PropertyType; string newPath = path + "." + expectedName; var comparisonResult = this.CompareProperty(expected, expectedName, expectedPropertyType, actualValue, newPath, shouldThrow); if (comparisonResult == ComparisonResult.Failure) { visited.Remove(actual); return(ComparisonResult.Failure); } if (comparisonResult == ComparisonResult.Skipped) { comparisonSkippedForAnyProperty = true; } } if (comparisonSkippedForAnyProperty) { this.AddToLogBuffer("Verifying structural value. Path: {0} SKIPPED", path); return(ComparisonResult.Skipped); } else { this.AddToLogBuffer("Verifying structural value. Path: {0} SUCCESSFUL", path); return(ComparisonResult.Success); } }
///// <summary> ///// 根据参数名称获取参数表达式 ///// </summary> ///// <param name="name">参数名称</param> ///// <returns>参数表达式</returns> //public ParameterExpression GetParameter(string name) //{ // if (Parameters != null) // { // foreach (ParameterExpression parameter in Parameters) // { // if (parameter.Name == name) return parameter; // } // } // return null; //} #if DOTNET35 /// <summary> /// 表达式转换 /// </summary> /// <param name="expression">表达式</param> /// <returns>表达式</returns> internal static LambdaExpression convert(System.Linq.Expressions.LambdaExpression expression) { return(new LambdaExpression(Expression.convert(expression.Body) , expression.Parameters.getArray(value => ParameterExpression.convert(value)))); }
/// <summary> /// not used /// </summary> public virtual Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression) { throw new NotImplementedException(); }
public MethodGraph SwitchImpl(System.Linq.Expressions.LambdaExpression expression, string newName = null, string oldName = null) { return(SwitchImpl(expression.Compile().Method, newName, oldName)); }
internal static object GetAlgorithmFromConfig(string algorithm) { if (string.IsNullOrEmpty(algorithm)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(algorithm))); } object algorithmObject = null; object defaultObject = null; if (!s_algorithmDelegateDictionary.TryGetValue(algorithm, out Func <object> delegateFunction)) { lock (s_algorithmDictionaryLock) { if (!s_algorithmDelegateDictionary.ContainsKey(algorithm)) { try { algorithmObject = CryptoConfig.CreateFromName(algorithm); } catch (TargetInvocationException) { s_algorithmDelegateDictionary[algorithm] = null; } if (algorithmObject == null) { s_algorithmDelegateDictionary[algorithm] = null; } else { defaultObject = GetDefaultAlgorithm(algorithm); if (defaultObject != null && defaultObject.GetType() == algorithmObject.GetType()) { s_algorithmDelegateDictionary[algorithm] = null; } else { // Create a factory delegate which returns new instances of the algorithm type for later calls. Type algorithmType = algorithmObject.GetType(); System.Linq.Expressions.NewExpression algorithmCreationExpression = Linq.Expressions.Expression.New(algorithmType); Linq.Expressions.LambdaExpression creationFunction = Linq.Expressions.Expression.Lambda <Func <object> >(algorithmCreationExpression); delegateFunction = creationFunction.Compile() as Func <object>; if (delegateFunction != null) { s_algorithmDelegateDictionary[algorithm] = delegateFunction; } return(algorithmObject); } } } } } else { if (delegateFunction != null) { return(delegateFunction.Invoke()); } } // // This is a fallback in case CryptoConfig fails to return a valid // algorithm object. CrytoConfig does not understand all the uri's and // can return a null in that case, in which case it is our responsibility // to fallback and create the right algorithm if it is a uri we understand // switch (algorithm) { case SHA256String: case SecurityAlgorithms.Sha256Digest: return(SHA256.Create()); case SecurityAlgorithms.Sha1Digest: return(SHA1.Create()); case SecurityAlgorithms.HmacSha1Signature: return(new HMACSHA1()); default: break; } return(null); }
public Sort(Remote.Linq.Expressions.SortExpression exp) { _queryExpression = exp.Operand; _orderingDirection = exp.SortDirection; _lambdaExpression = null; }
public Sort(Remote.Linq.Expressions.LambdaExpression exp, Remote.Linq.Expressions.SortDirection orderingDirection) { _queryExpression = exp; _orderingDirection = orderingDirection; _lambdaExpression = null; }
public Filter(Remote.Linq.Expressions.LambdaExpression exp) { _queryExpression = exp; _lambdaExpression = null; }
private static Remote.Linq.Expressions.LambdaExpression GetOrCreateRemoteExpression(Remote.Linq.Expressions.LambdaExpression remoteExpression, System.Linq.Expressions.LambdaExpression systemExpression) { return(remoteExpression ?? ToRemoteExpression(systemExpression)); }
public abstract void MarkSequencePoint(System.Linq.Expressions.LambdaExpression method, int ilOffset, System.Linq.Expressions.DebugInfoExpression sequencePoint);
public Filter(System.Linq.Expressions.LambdaExpression exp) { _lambdaExpression = exp; _queryExpression = null; }