выражение linq для дат, фильтрованных по дням, месяцам и годам

Данные не найдены, используя EQUAL? из-за разницы во времени? Может ли кто-нибудь показать мне, как создать допустимое выражение для даты?выражение linq для дат, фильтрованных по дням, месяцам и годам

Таблица

UserId  Username        DateCreated 
466   [email protected]   5/10/1980 5:18:18 AM 
467   [email protected]    5/10/1980 5:18:18 AM 
502   [email protected]   5/10/1980 5:18:18 AM 
534   [email protected]    5/10/1980 5:18:18 AM 
535   [email protected]    5/10/1980 5:18:18 AM 
570   [email protected]    4/10/1980 5:18:18 AM 
607   [email protected]   4/10/1980 4:17:17 AM 
608   [email protected]    4/10/1980 4:17:17 AM 
642   [email protected]    4/10/1980 4:17:17 AM 
643   [email protected]    4/10/1980 4:17:17 AM

Как создать выражение LINQ для дат отфильтрованных на день, месяц и год только с помощью Linq Expression Builder?

У меня есть класс «TableExpression.cs», который обрабатывает все фильтры «Где ИмяПоля ..», «Заказы»

Вместо фильтрации

new Filters{FieldName="DateCreated",FieldValue= new DateTime(1980,10,10),LinqExprOpr = LinqExprOperator.LessThanOrEqual,LinqExprSrt = LinqExprSort.OrderBy,IsSortedField = false}, 
    new Filters{FieldName="DateCreated",FieldValue= new DateTime(1979,10,10),LinqExprOpr = LinqExprOperator.GreaterThanOrEqual,LinqExprSrt = LinqExprSort.ThenBy,IsSortedField = false}

Я надеялся, что фильтровать его с помощью equal (=) Оператор.

new Filters{FieldName="DateCreated",FieldValue= new DateTime(1980,10,10),LinqExprOpr = **LinqExprOperator.Equal**,LinqExprSrt = LinqExprSort.OrderBy,IsSortedField = false},

My Dynamic Expression Builder Класс

enter code here 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Linq.Expressions; 
using System.Reflection; 
using Common; 

namespace DataAccess.Config.TableExpression 
{ 
    public static class ExressionBuilderV3 
    { 
     public static IQueryable<T> CreateExpressions<T>(IList<Filters> _filters, IQueryable<T> source) 
     { 
      Type ParmType = typeof(T); 
      ParameterExpression ParmExpr = Expression.Parameter(ParmType, ParmType.Name); 
      Expression ListOfExpr = null; 
      // Condition Query 
      foreach (var f in _filters) 
      { 
       PropertyInfo pInfo = ParmType.GetProperties().Where(_ => _.Name == f.FieldName).FirstOrDefault(); 
       Type FieldType = Type.GetType(pInfo.PropertyType.FullName); 
       if (ListOfExpr == null) 
       { 
        ListOfExpr = AddOperatorExpression(ParmExpr, f.FieldName, f.FieldValue, FieldType, f.LinqExprOpr); 

       } 
       else 
       { 
        ListOfExpr = AddBitWiseExpression(ListOfExpr, 
                 AddOperatorExpression(ParmExpr, f.FieldName, f.FieldValue, FieldType, f.LinqExprOpr) 
                , f.LinqExprBtw); 
       } 
      } 
      // Sort Query 
      Expression<Func<T, bool>> ExprTotal = Expression.Lambda<Func<T, bool>>(ListOfExpr, ParmExpr); 
      source = source.Where(ExprTotal); 
      ListOfExpr = null; 
      foreach (var f in _filters) 
      { 
       PropertyInfo pInfo = ParmType.GetProperties().Where(_ => _.Name == f.FieldName).FirstOrDefault(); 
       Type FieldType = pInfo.PropertyType; 
       //***************************************************************************************************** 
       if (f.IsSortedField) 
       { 
        source = Sorting(source, ParmType, f.FieldName, f.LinqExprSrt); 
       } 
       //***************************************************************************************************** 
      } 
      Filters filter = _filters.SingleOrDefault(_ => _.IsSortedField == true && _.PageSize > 0); 
      if (filter != null) 
      { 
       source = source.Skip((filter.PageIndex -1) * filter.PageSize).Take(filter.PageSize); 
      } 
      return source; 
     } 

     private static Expression AddBitWiseExpression(Expression _Expression1, Expression _Expression2, LinqExprBitWise _LinqExprBitWise) 
     { 
      Expression RtrnExpression = null; 
      switch (_LinqExprBitWise) 
      { 
       case LinqExprBitWise.Or: 
        RtrnExpression = Expression.Or(_Expression1, _Expression2); 
        break; 
       case LinqExprBitWise.AndAlso: 
        RtrnExpression = Expression.AndAlso(_Expression1, _Expression2); 
        break; 
      } 
      return RtrnExpression; 
     } 

     private static Expression AddOperatorExpression(ParameterExpression _ParmExpr, String _FieldName, object _FieldValue, Type _typeOf, LinqExprOperator _operator) 
     { 

      Expression FieldName = Expression.Property(_ParmExpr, _FieldName); 
      Expression FieldValue = Expression.Constant(_FieldValue, _typeOf); 

      Expression rtrnExpr = null; 
      #region 
      switch (_operator) 
      { 
       case LinqExprOperator.Equals: 
        rtrnExpr = Expression.Equal(FieldName, FieldValue); 
        break; 
       case LinqExprOperator.GreaterThan: 
        rtrnExpr = Expression.GreaterThan(FieldName, FieldValue); 
        break; 
       case LinqExprOperator.GreaterThanOrEqual: 
        rtrnExpr = Expression.GreaterThanOrEqual(FieldName, FieldValue); 
        break; 
       case LinqExprOperator.LessThan: 
        rtrnExpr = Expression.LessThan(FieldName, FieldValue); 
        break; 
       case LinqExprOperator.LessThanOrEqual: 
        rtrnExpr = Expression.LessThanOrEqual(FieldName, FieldValue); 
        break; 
       case LinqExprOperator.Contains: 
        rtrnExpr = Expression.Call(FieldName, typeof(string).GetMethod("Contains"), FieldValue); 
        break; 
       case LinqExprOperator.StartsWith: 
        rtrnExpr = Expression.Call(FieldName, typeof(string).GetMethod("StartsWith", new Type[] { typeof(string) }), FieldValue); 
        break; 
       case LinqExprOperator.EndsWith: 
        rtrnExpr = Expression.Call(FieldName, typeof(string).GetMethod("EndsWith", new Type[] { typeof(string) }), FieldValue); 
        break; 
      } 
      #endregion 
      return rtrnExpr; 
     } 

     private static IQueryable<T> Sorting<T>(IQueryable<T> _Source, Type _ParmType, String _FieldName, LinqExprSort _LinqExprSort) 
     { 
      string orderMethodName = ""; 
      switch (_LinqExprSort) 
      { 
       case LinqExprSort.OrderBy: 
        orderMethodName = "OrderBy"; 
        break; 
       case LinqExprSort.OrderByDescending: 
        orderMethodName = "OrderByDescending"; 
        break; 
       case LinqExprSort.ThenBy: 
        orderMethodName = "ThenBy"; 
        break; 
       case LinqExprSort.ThenByDescending: 
        orderMethodName = "ThenByDescending"; 
        break; 
      } 

      var param = Expression.Parameter(_ParmType); 
      var property = _ParmType.GetProperty(_FieldName); 

      return _Source.Provider.CreateQuery<T>(
       Expression.Call(
        typeof(Queryable), 
        orderMethodName, 
        new Type[] { _ParmType , property.PropertyType }, 
        _Source.Expression, 
        Expression.Quote(
         Expression.Lambda(
          Expression.Property(param, property), 
          param)) 
       )); 
     } 

     /***************************************************************************/ 
    } 
}

источник

2015-02-26 Luffy

-1

Что вам нужно, это метод преобразования в этом случае (Func<DateTime, DateTime>)(x =>{ return x.Date;}), чтобы дать вам только часть даты. Если вы посмотрите на мой пример ниже, вы увидите, что когда-либо у меня есть метод преобразования, я использую Method.Call с методом преобразования и соответствующим выражением в качестве входных данных. Это позволяет преобразовать любой другой тип объекта перед сравнением.

void static Main() 
{ 
    var ops = new List<Ops> 
    { 
     /*new Ops 
     { 
      OperandType = typeof(string), 
      OpType=OpType.Equals, 
      OperandName = "Name", 
      ValueToCompare = "MM" 
     }, 
     new Ops 
     { 
      OperandType = typeof(string), 
      OpType=OpType.Equals, 
      OperandName = "ID", 
      ValueToCompare = 1 
     },*/ 
     new Ops 
     { 
      OperandType = typeof(DateTime), 
      OpType=OpType.Equals, 
      OperandName = "Date", 
      ValueToCompare = new DateTime(2014,12,1), 
      //key is this transformation method 
      TransformationMethod = ((Func<DateTime, DateTime>)(x =>{ return x.Date;})).Method 
     }, 
    }; 
    var testClasses = new List<TestClass> 
    { 
     new TestClass { ID =1, Name = "MM", Date = new DateTime(2014,12,1,2,32,10)}, 
     new TestClass { ID =2, Name = "BB", Date = new DateTime(2014,12,2)} 
    }; 

    var funct = ExpressionBuilder.BuildExpressions<TestClass>(ops); 
    foreach(var item in testClasses.Where(funct)) 
    { 
     Console.WriteLine("ID " +item.ID); 
     Console.WriteLine("Name " +item.Name); 
     Console.WriteLine("Date" + item.Date); 
    } 
}

// Определение других методов и классов здесь общественных перечисления OpType { Равно }

public class Ops 
{ 
    public Type OperandType {get; set;} 

    public OpType OpType {get; set;} 

    public string OperandName {get;set;} 

    public object ValueToCompare {get;set;} 

    public MethodInfo TransformationMethod{get;set;} 
} 

public class TestClass 
{ 
    public int ID {get;set;} 
    public string Name {get; set;} 
    public DateTime Date {get;set;} 
} 

public class ExpressionBuilder 
{ 
    public static Func<T,bool> BuildExpressions<T>(List<Ops> opList) 
    { 
     Expression currentExpression= null; 
     var parameter = Expression.Parameter(typeof(T), "prop"); 
     for(int i =0; i< opList.Count; i++) 
     { 
      var op = opList[i]; 
      Expression innerExpression = null; 
      switch(op.OpType) 
      { 
       case OpType.Equals : 
       { 
        var innerParameter = Expression.Property(parameter,op.OperandName); 
        //Console.WriteLine(innerParameter); 
        var ConstExpression = Expression.Constant(op.ValueToCompare); 
        //Console.WriteLine(ConstExpression); 
        if(op.TransformationMethod != null) 
        { 
         innerExpression = Expression.Equal(Expression.Call(op.TransformationMethod, new []{innerParameter}), 
                  Expression.Call(op.TransformationMethod, new []{ConstExpression})); 
         //Console.WriteLine(innerExpression); 
        } 
        else 
         innerExpression = Expression.Equal(innerParameter, ConstExpression); 
        break; 
       } 
      } 

      if (i >0) 
      { 
       currentExpression = Expression.And(currentExpression, innerExpression); 
      } 
      else 
      { 
       currentExpression = innerExpression; 
      } 
     } 
     var lambdaExpression = Expression.Lambda<Func<T,bool>>(currentExpression, new []{parameter}); 
     //Console.WriteLine(lambdaExpression); 
     return lambdaExpression.Compile() ; 
    } 
}

источник

2015-02-26 19:56:28 TYY

спасибо за ответ. Это то, что мне нужно. Спасибо. – Luffy

Работает как шарм. Четкое кодирование. Благодарю. – Luffy

Не беспокойтесь. Меня действительно интересовало. Я создал это раньше, но никогда не сравнивал дату. Так что это дало мне шанс сделать это. – TYY

выражение linq для дат, фильтрованных по дням, месяцам и годам

ответ

Смежные вопросы