EF-code d'abord - IQueryable ayant multiplication sur une propriété décimale spécifique

Question

J'ai été aux prises avec le problème suivant sur Entity Framework code-first.

J'ai une classe d'entité avec un nombre décimal, et j'ai un paramètre décimal multiplicateur.

Je souhaite créer une requête (sans l'appeler), qui renvoie les entités, mais la propriété Bar doit être multipliée avec mon paramètre.

De côté codage:

public class Foo 
{ 
    public Guid Id { get; set; } 
    public Decimal Bar { get; set; } 
} 

// this simple stuff returns the entities after some filterings. 
Context.Set<Foo>().Where(x => querying on many props).ToList(); 

Cette méthode est similaire ce que je veux atteindre:

public IQueryable<Foo> GetFooQuery(.. Many properties used to the query .. , Decimal Multiplier) 
{ 
    var IQueryablePart = Context.Set<Foo>().Where(querying with the parameters); 

    /* ... and what to do here? ... */ 
    /* IQueryablePart = IQueryablePart.Select(x => new { 
      Bar = Bar * Multiplier <-- this is okay 
     }); */ 
    // but how to retrieve the other columns without listing them one by one, and how to return the data as IQueryable<Foo> ? 

    return IQueryablePart; 
} 

Je voudrais utiliser cette méthode de la manière suivante:

IQueryable<Foo> FullQuery = null; 

for(some loop, may be 10 or 1000 iterations, it depends) { 
    var Part = GetFooQuery(/* .. query params ..*/, 2); 

    if(MyFullQuery == null) 
     FullQuery = Part; 
    else 
     FullQuery.Union(Part); 
} 

// and in the end, do the db call once: 
var Result = FullQuery.ToList(); 

En SQL, je voudrais le gérer comme ceci:

SELECT 
    Id, 
    Bar * @MyValue as Bar, 
    # and all other columns 
FROM 
    Foo 
WHERE 
    (param queries 1) OR 
    (param queries 2) OR 
    --- 
    (param queries N) 

Ma question est: quelle est la façon de le faire via IQueryable et EF? Le plus important, je dois appeler le DB une seule fois. Je pense qu'il peut s'agir d'un peu de construction de requêtes, mais je ne suis pas encore familier avec cela, toute aide sera très appréciée.

Answer 1

EF6 ne prend pas en charge la projection (select) dans une classe mappée en tant qu'entité. Par conséquent, la seule option que vous avez est de projeter vers une classe anonyme ou spéciale. Pour votre scénario, le plus facile que je vois est une classe comme ceci:

public class FooBar 
{ 
    public Foo Foo { get; set; } 
    public decimal Bar { get; set; } 
} 

Ensuite, la méthode de requête unique pourrait ressembler à ceci:

public IQueryable<FooBar> GetFooQuery(.. Many properties used to the query .. , decimal multiplier) 
{ 
    return Context.Set<Foo>() 
     .Where(querying with the parameters) 
     .Select(foo => new FooBar 
     { 
      Foo = foo, 
      Bar = foo.Bar * multiplier 
     }); 
} 

vous pouvez maintenant construire votre requête complète:

IQueryable<FooBar> fullQuery = null; 

for (some loop, may be 10 or 1000 iterations, it depends) 
{ 
    var subQuery = GetFooQuery(/* .. query params ..*/, 2); 

    fullQuery = fullQuery == null ? subquery : fullQuery.Union(subQuery); 
} 

Notez que si vous utilisez un multiplicateur différent (sinon toute la procédure n'a pas de sens), vous feriez mieux d'utiliser la méthode LINQ (qui se traduit par SQL UNION ALL) plutôt en Union (qui se traduit par SQL UNION).

Enfin, vous pouvez matérialiser le résultat comme Foo sequennce en exécutant la requête SQL finale unique, le passage à LINQ aux objets et convertir le FooBar à Foo comme ceci:

var result = fullQuery. 
    .AsEnumerable() // db query ends here 
    .Select(fooBar => 
    { 
     fooBar.Foo.Bar = fooBar.Bar; 
     return fooBar.Foo; 
    }) 
    .ToList();