Hallo zusammen,

kann man LINQ to Entities nicht irgendwie dazu überreden, Methoden zu akzeptieren, die nur ein weiteres Query enthalten? Beispiel:

void Main()
{
    var activeProducts1 = (from p in db.Products
                           where p.Active && p.Price > 100
                           select p).ToList();
    var activeProducts2 = (from p in GetActiveProducts()
                           where p.Price > 100
                           select p).ToList();
    var activeProducts3 = (from p in Products
                           join ap in GetActiveProducts() on p.ProductID equals ap.ProductID
                           where p.Price > 100 && ap.Price < 200
                           select p).ToList();
    var activeProducts4 = (from p in db.Products
                           where p.Price > 100
                           select new {
                             Product = p,
                             ActiveProducts = GetActiveProducts()
                           }).ToList();
}

ObjectQuery<Product> GetActiveProducts()
{
    return (from p in db.Products
            where p.Active
            select p) as ObjectQuery<Product>;
}

Die ersten beiden LINQ Statements resultieren im gleichen SQL Query. Mal abgesehen davon, dass das 3. und 4. Query wenig Sinn macht, scheitert der Aufruf des 4., weil LINQ to Entities den Methodenaufruf nicht übersetzen kann. Aber warum schafft es das beim 2. und sogar beim 3. Aufruf?

Und was bleibt als Alternativlösung? Alle Abfrageteile, die in etlichen anderen Abfragen vorkommen, via Copy/Paste übernehmen? Das kann nicht der Weisheit letzter Schluss sein.

Zu deiner ersten Frage, dem "Warum" gibt Microsoft folgende Erklärung:
Verweise auf nicht skalare Abschlüsse werden nicht unterstützt
Zu deiner zweiten Frage, der "Alternativlösung", suche im Internet nach den Begriffen extension methods lambda
Ich benötigte ein "string based order by" und realisierte es folgendermaßen:

namespace System.Linq
{
    /// <summary>
    ///   LambdaExtenders
    /// </summary>
    public static class LambdaExtender
    {
        /// <summary>
        ///   string based orderby
        /// </summary>
        /// <typeparam name = "T"></typeparam>
        /// <param name = "items"></param>
        /// <param name = "property"></param>
        /// <param name = "ascending"></param>
        /// <returns></returns>
        public static IOrderedEnumerable<T> MyOrderBy<T>(this IEnumerable<T> items, string property, bool ascending)
        {
            try
            {
                ParameterExpression myObject = Expression.Parameter(typeof (T), "MyObject");
                ParameterExpression myEnumeratedObject = Expression.Parameter(typeof (IEnumerable<T>),
                                                                              "MyEnumeratedObject");
                MemberExpression myProperty = Expression.Property(myObject, property);
                LambdaExpression myLamda = Expression.Lambda(myProperty, myObject);
                MethodCallExpression myMethod = Expression.Call(typeof (Enumerable),
                                                                ascending ? "OrderBy" : "OrderByDescending",
                                                                new[] {typeof (T), myLamda.Body.Type},
                                                                myEnumeratedObject, myLamda);
                Func<IEnumerable<T>, IOrderedEnumerable<T>> mySortedLamda =
                    Expression.Lambda<Func<IEnumerable<T>, IOrderedEnumerable<T>>>(myMethod, myEnumeratedObject).Compile();
                return mySortedLamda(items);
            }
            catch (Exception ex)
            {
                throw new Exception(string.Concat("MyOrderBy exception\n", ex.Message), ex.InnerException);
            }
        }
    }
}

Der Aufruf kann folgendermaßen aussehen:

var dataGridPageSizes = from p in entities.DataGridPageSize select p;
dataGridPageSizes = dataGridPageSizes.MyOrderBy("PageSize", true).AsQueryable();

Eventuell kommst du damit weiter. Versprechen kann ich es nicht.

Hallo,

eventuell ist Using the LINQ Dynamic Query Library hilfreich für dich auch wenn sie nicht alle LINQ Extensions anbietet, so ist sie doch auch mit LINQ to Entities verwendbar.

Ein aktuellerer blog Eintrag für C# 4.0 der sich auf obigen bezieht.

Grüße

Hallo Daniel,

hast Du Dir schon einmal Codesmith angeschaut?
http://www.codesmithtools.com/

Und dort Plinqo im speziellen? Dies gibt es einmal als replacement für das Entity Framework von MS und auch als replacement von LINQ to SQL. Ich habe damit extrem gute Erfahrung gemacht!
Das Tool Codesmith muss zwar erworben werden, doch das Framework Plinqo ist kostenlos, hat eine sehr gute Comunity und auf bugs wird schnell reagiert.
Bei Plinqo wird jede Tabelle als eigenständige Entity generiert. Es gibt query extensions, die Du beliebig erweitern kannst, sozusagen Entity auf Knopfdruck.
Du kannst Dir das ja mal in der Trial anschaun. Ich kann gar nicht mehr ohne, da es abgesehen vom Plinqo Framework, einem viel Tipparbeit abnimmt, wenn man sich einmal Templates gebastelt hat.

Folgendes geht mit Plinqo z.b:

Dim IMyTableQueryAble = PlinqoDatacontext.TableName.GetByStartDat(Date)
IMyTableQueryAble = IMyTableQueryAble.GetBySomething(CodeSmith.Data.Linq.ComparisonOperator.GreaterThanOrEquals, 15)
IMyTableQueryAble = IMyTableQueryAble.GetBySomethingMore(CodeSmith.Data.Linq.ComparisonOperator.LessThanOrEquals, 30)
Dim Test = from Items in IMyTableQueryAble Select ....