Ekspresja.GreaterThan fails, if one operand is nullable type, other is non-nullable

Gdzie jest twoje porównanie, Zmień porównanie TAK:

(nullableDT >= DT)

Do

(nullableDT != null && nullableDT.Value >= DT)

Edit:

Zgodnie z Twoim komentarzem, napisz funkcję, która zajmuje 2 obiekty, wewnątrz funkcji sprawdź, czy są to typy null, i sprawdź, czy są null, a następnie porównaj wartości. Ta funkcja będzie prawdopodobnie używać kodu podobnego do ^.

Znalazłem rozwiązanie, które działa w. Net framework. Tutaj metoda, która jest nadal w toku, ale działa i działa dla LINQ do encji:

public PagedViewModel<T> Filter<TValue>(Expression<Func<T, TValue>> predicate, FilterType filterType = FilterType.Equals) {
        var name = (predicate.Body as MemberExpression ?? ((UnaryExpression)predicate.Body).Operand as MemberExpression).Member.Name;            
        var value = Expression.Constant(ParamsData[name].To<TValue>(), typeof (T).GetProperty(name).PropertyType);                        

        // If nothing has been set for filter, skip and don't filter data.
        ViewData[name] = m_QueryInternal.Distinct(predicate.Compile()).ToSelectList(name, name, ParamsData[name]);
        if (string.IsNullOrWhiteSpace(ParamsData[name]))
            return this;

        var nameExpression = Expression.Parameter(typeof(T), name);
        var propertyExpression = Expression.Property(nameExpression, typeof(T).GetProperty(name));

        // Create expression body based on type of filter
        Expression expression;
        MethodInfo method;
        switch(filterType) {
            case FilterType.Like:
                method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
                expression = Expression.Call(propertyExpression, method, value); 
                break;
            case FilterType.EndsWith:
            case FilterType.StartsWith:
                method = typeof(string).GetMethod(filterType.ToString(), new[] { typeof(string) });
                expression = Expression.Call(propertyExpression, method, value);
                break;
            case FilterType.GreaterThan:
                expression = Expression.GreaterThan(propertyExpression, value);                    
                break;
            case FilterType.Equals:
                expression = Expression.Equal(propertyExpression, value);
                break;
            default:
                throw new ArgumentException("Filter Type could not be determined");
        }            

        // Execute the expression against Query.
        var methodCallExpression = Expression.Call(
            typeof (Queryable),
            "Where",
            new[] { Query.ElementType },
            Query.Expression,
            Expression.Lambda<Func<T, bool>>(expression, new[] { nameExpression }));

        // Filter the current Query data.
        Query = Query.Provider.CreateQuery<T>(methodCallExpression);            

        return this;
    }

To, co się tutaj dzieje, to wartość stała wyrażenia jest rzucana do typu predykatu. Dla jasności metoda ta jest wywoływana przez:

var paramsData = new NameValueCollection { { "CreatedOn", DateTime.Today.ToString() } };
        var model = m_data.ToPagedList(new ViewDataDictionary(), paramsData, 1, 10, null, x => x.LastName)
                          .Filters(Criteria<TrainerProfile>.New(x => x.CreatedOn, FilterType.GreaterThan))
                          .Setup();

Ten kod jest oparty na MVC 3, stąd niektóre z ParamsData [""], które jest (Request.Params).

Nie jestem pewien dokładnie jaki jest Twój kod, ale aby uzyskać nie-nullable wersję Nullable, zadzwoń do jego .Value członka.

To zabawne.]}

Próbowałem obu wariantów tego kodu:

    System.Nullable<DateTime> now = new System.Nullable<DateTime>();
    now = DateTime.Now;

I

    System.Nullable<DateTime> now;
    now = DateTime.Now;

I obie pracowały bez błędów.

(now > = DateTime.Teraz) w zapytaniu Linq pojawi się błąd. Powinno być (teraz.Wartość > = DateTime.Teraz)