Immer gerade/ungerade Teil einer Sequenz mit LINQ

Sagen, dass ich eine Liste aller Projects, und dass ich diese Gruppe von Category wie diese:

var projectsByCat = from p in Projects
                    group p by p.Category into g
                    orderby g.Count() descending
                    select new { Category = g.Key, Projects = g };

Nun will ich anzeigen dies als eine Liste in einer web-Seite, wo ich zuerst erstellen Sie die linke Seite div, zweitens der rechten Seite div. Ich bestelle durch die Anzahl der Projects in jedem Category zu zeigen, die Categories mit den meisten Projects auf der Oberseite - damit möchte ich split projectsByCat in zwei - wenn ich alle "ungeraden" Categories auf der linken Seite und die "geraden" Kategorien auf der rechten Seite, ich denke, dass ich eine halbwegs vernünftige Ansicht.

So, ich dachte, ich könnte dies tun, um die ungerade und sogar Mitglieder projectsByCat:

var oddCategories = projectsByCat.Where((cat, index) => index % 2 != 0);

var evenCategories = projectsByCat.Where((cat, index) => index % 2 == 0);

Und es kompiliert - aber, wenn ich es laufen lasse, bekomme ich eine Ausnahme wie diese:

Nicht unterstützte überlast für query-operator 'Wo'.

Und ich dachte, ich war sicher, da es kompiliert in den ersten Platz.. 😉

Gibt es einen eleganten Weg, dies zu tun? Und außerdem ist es eine elegante Erklärung dafür, warum meine kreative Nutzung von Where() funktioniert nicht?

Vielen Dank im Voraus!

InformationsquelleAutor Rune Jacobsen | 2008-11-05

c#linq

42

Wenn Sie mithilfe von LINQ to SQL oder LINQ to Entities sollten Sie zunächst vollständig materialisieren die Ergebnisse in den Speicher:
```
var oddCategories  = projectsByCat.ToList().Where((c,i) => i % 2 != 0);
var evenCategories = projectsByCat.ToList().Where((c,i) => i % 2 == 0);
```
Ist es nicht möglich zu Durchlaufen und die Ergebnisse auf der Datenbank mit einem indexer, ohne die Verwendung eines Cursors, der entweder ORM-framework nicht nicht tun.

Das hat es - ich glaube 95% LINQ to objects so die Möglichkeit das ein problem mit LINQ to SQL nicht einmal mich zu schlagen. Danke!

InformationsquelleAutor Mark Cidade

Beachten Sie, dass der Aufruf .ToList() zweimal für die gleiche Abfrage wird die Abfrage der Datenbank doppelt.

Wäre es viel besser, cache das Ergebnis in einer temporären Liste dann wenden Sie Ihr Prädikat Filterung:

var projectsByCat =
    (from p in Projects
    group p by p.Category into g
    orderby g.Count() descending
    select new { Category = g.Key, Projects = g }).ToList();

var oddCategories = projectsByCat.Where((cat, index) => index % 2 != 0);
var evenCategories = projectsByCat.Where((cat, index) => index % 2 == 0);

InformationsquelleAutor Jacob Carpenter

Den oddCategories und die evenCategories abwärts.

Indizes starten mit 0 und nicht mit 1

0 % 2 = 0

0 index ungerade ist.

var oddCategories  = projectsByCat.Where((cat, index) => index % 2 == 0);

var evenCategories = projectsByCat.Where((cat, index) => index % 2 != 0);

InformationsquelleAutor bjhamltn

4

Den richtigen Weg, dies zu tun ist die Verwendung von LINQ, und die Vermeidung von mehreren Aufzählungen über dem Eingang, ist eine Gruppierung oder ähnliches, ob jedes Element ist entweder gerade oder ungerade.

Einfache Weise mit der überlastung für Select dass mischt in einem index gepaart mit ToLookup gibt Ihnen, was Sie wollen:
```
var oddsAndEvens = input
    .ToList() //if necessary to get from IQueryable to IEnumerable
    .Select((item, index) => new { isEven = index % 2 != 0, item })
    .ToLookup(
        i => i.isEven,
        i => i.item);
```
Dies wird produzieren ein Lookup<TKey, TElement> Daten-Struktur, hat die folgenden nutzen:

Wenn der Schlüssel nicht in der Auflistung gefunden, wird eine leere Sequenz zurückgegeben wird.

Dies bedeutet, dass nach der oben LINQ-Abfrage, die Sie tun können:
```
var evens = oddsAndEvens[true];
var odds = oddsAndEvens[false];
```
InformationsquelleAutor Lasse Vågsæther Karlsen

Können Sie separate gerade und ungerade in Ihren anzeigen mit linq.

//even 
@foreach (var item in Model.Where((item, index) => index % 2 == 0))
{
     //do the code
}

//odd
@foreach (var item in Model.Where((item, index) => index % 2 != 0))
{
     //do the code
}

InformationsquelleAutor Athul Nalupurakkal

Finden Sie Auch ungerade Zahl ohne foreach-Schleife

static void Main(string[] args)
{
    List<int> lstnum = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

    List<int> lstresult = lstnum.FindAll(x => (x % 2) == 0);

    lstresult.ForEach(x => Console.WriteLine(x));
}

InformationsquelleAutor Hrishikesh Kulkarni

var text = "this is a test <string> to extract odd <index> values after split";
var parts = text.Split(new char[] { '<', '>' });
IEnumerable words = parts.Where(x => parts.ToList().IndexOf(x) % 2 == 1)

Worte enthalten würde, "string" und "index"

InformationsquelleAutor Sam Saarian

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.