Expression >和Func

1.Expression<Func<T,TResult>>是表達式

//使用LambdaExpression構建表達式樹
            Expression<Func<int, int, int, int>> expr = (x, y, z) => (x + y) / z;
            Console.WriteLine(expr.Compile()(1, 2, 3));

https://msdn.microsoft.com/zh-cn/library/system.linq.expressions.expression(v=vs.100).aspx

https://msdn.microsoft.com/zh-cn/library/bb335710(v=vs.100).aspx

 

2.Func<T, TResult> 委托

封裝一個具有一個參數並返回 TResult 參數指定的類型值的方法。
public delegate TResult Func<in T, out TResult>(T arg)
類型參數
in T
此委托封裝的方法的參數類型。
該類型參數是逆變的。即可以使用指定的類型或派生程度更低的類型。有關協變和逆變的更多信息，請參見泛型中的協變和逆變。
out TResult
此委托封裝的方法的返回值類型。
該類型參數是協變的。即可以使用指定的類型或派生程度更高的類型。有關協變和逆變的更多信息，請參見泛型中的協變和逆變。
參數
arg
類型：T
此委托封裝的方法的參數。
返回值
類型：TResult
此委托封裝的方法的返回值。

  string mid = ",middle part,";
            ///匿名寫法
            Func<string, string> anonDel = delegate(string param)
            {
                param += mid;
                param += " And this was added to the string.";
                return param;
            };
            ///λ表達式寫法
            Func<string, string> lambda = param =>
                {
                    param += mid;
                    param += " And this was added to the string.";
                    return param;
                };
            ///λ表達式寫法(整形)
            Func<int, int> lambdaint = paramint =>
                {
                    paramint = 5;
                    return paramint;
                };
            ///λ表達式帶有兩個參數的寫法
            Func<int, int, int> twoParams = (x, y) =>
                {
                  return  x*y;
                };
            MessageBox.Show("匿名方法："+anonDel("Start of string"));
            MessageBox.Show("λ表達式寫法:" + lambda("Lambda expression"));
            MessageBox.Show("λ表達式寫法(整形):" + lambdaint(4).ToString());
            MessageBox.Show("λ表達式帶有兩個參數:" + twoParams(10, 20).ToString());

 來自:

http://blog.csdn.net/shuyizhi/article/details/6598013

3.使用Expression進行查詢拼接

    public static class DynamicLinqExpressions
     {
 
         public static Expression<Func<T, bool>> True<T>() { return f => true; }
         public static Expression<Func<T, bool>> False<T>() { return f => false; }
 
         public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1,
                                                             Expression<Func<T, bool>> expr2)
         {
             var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast<Expression>());
             return Expression.Lambda<Func<T, bool>>
                   (Expression.Or(expr1.Body, invokedExpr), expr1.Parameters);
         }
 
         public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr1,
                                                              Expression<Func<T, bool>> expr2)
         {
             var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast<Expression>());
             return Expression.Lambda<Func<T, bool>>
                   (Expression.And(expr1.Body, invokedExpr), expr1.Parameters);
         }
 
     }

使用方法

       public static IEnumerable<T> FilterBy<T>(this IEnumerable<T> collection, IEnumerable<KeyValuePair<string, string>> query)
         {
             var filtersCount = int.Parse(query.SingleOrDefault(k => k.Key.Contains("filterscount")).Value);
             
             Expression<Func<T, bool>> finalquery = null;
 
             for (var i = 0; i < filtersCount; i += 1)
             {
                 var filterValue = query.SingleOrDefault(k => k.Key.Contains("filtervalue" + i)).Value;
                 var filterCondition = query.SingleOrDefault(k => k.Key.Contains("filtercondition" + i)).Value;
                 var filterDataField = query.SingleOrDefault(k => k.Key.Contains("filterdatafield" + i)).Value;
                 var filterOperator = query.SingleOrDefault(k => k.Key.Contains("filteroperator" + i)).Value;
 
                 Expression<Func<T, bool>> current = n => GetQueryCondition(n, filterCondition, filterDataField, filterValue);
 
                 if (finalquery == null)
                 {
                     finalquery = current;
                 }
                 else if (filterOperator == "1")
                 {
                     finalquery = finalquery.Or(current);
                 }
                 else
                 {
                     finalquery = finalquery.And(current);
                 }
             };
 
             if (finalquery != null)
                 collection = collection.AsQueryable().Where(finalquery);
 
             return collection;
         }

要使用AsQueryable，必須引入 LinqKit.EntityFramework；如果不使用AsQueryable將會報錯。

 

4.關於SelectListItem的擴展 

using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Web.Mvc;
using System.Web.UI;

namespace Web.Helper
{
    public static class SelectListItemExtensions
    {
        /// <summary>
        /// Data.ToSelectListItems(s=>s.Id,s=>s.Name);
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="baseEntities"></param>
        /// <param name="valueExpression"></param>
        /// <param name="textExpression"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static IEnumerable<SelectListItem> ToSelectListItems<T>(this IEnumerable<T> baseEntities, Expression<Func<T, string>> valueExpression, Expression<Func<T, string>> textExpression, object defaultValue = null)
        {
            dynamic valueNameObject = valueExpression.Body.GetType().GetProperty("Member").GetValue(valueExpression.Body, null);
            dynamic textNameobject = textExpression.Body.GetType().GetProperty("Member").GetValue(textExpression.Body, null);

            var valueName = (string)valueNameObject.Name;
            var textName = (string)textNameobject.Name;

            return ToSelectListItems(baseEntities, valueName, textName, null);
        }
        /// <summary>
        /// Data.ToSelectListItems("Id", "Name")
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="baseEntities"></param>
        /// <param name="valueName"></param>
        /// <param name="textName"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static IEnumerable<SelectListItem> ToSelectListItems<T>(this IEnumerable<T> baseEntities, string valueName, string textName, object defaultValue = null)
        {
            if (string.IsNullOrWhiteSpace(valueName) || string.IsNullOrWhiteSpace(textName))
            {
                return new List<SelectListItem>();
            }
            var selectListItem = new List<SelectListItem>();
            if (defaultValue != null)
            {
                foreach (var baseEntity in baseEntities)
                {
                    var itemValue = GetPropertyValue(baseEntity, valueName);
                    selectListItem.Add(new SelectListItem()
                    {
                        Value = itemValue.ToString(),
                        Text = GetPropertyValue(baseEntity, textName).ToString(),
                        Selected = itemValue == defaultValue
                    });
                }
            }
            else
            {
                foreach (var baseEntity in baseEntities)
                {
                    selectListItem.Add(new SelectListItem()
                    {
                        Value = GetPropertyValue(baseEntity, valueName).ToString(),
                        Text = GetPropertyValue(baseEntity, textName).ToString(),
                    });
                }
            }

            return selectListItem;
        }

        public static object GetPropertyValue(object obj, string propertyName)
        {
            //反射去獲得對象的某個屬性值
            //Type t = obj.GetType();
            //PropertyInfo info = t.GetProperty(propertyName);
            //return info.GetValue(obj, null); //設置為SetValue

            return DataBinder.GetPropertyValue(obj, propertyName);
            //return DataBinder.Eval(obj, propertyName);
        }


    }
}

 

 

原文：http://blog.csdn.net/nabila/article/details/8137169