LINQ l'Élément Suivant dans la Liste

De prendre un coup d'oeil à ma question ICI, je veux maintenant revenir le lendemain recommandation objet (après) celle qui correspond aux critères.

Donc dire que j'ai trouvé l'article 6 sur 10, j'aimerais que la requête pour retourner des articles 7 à la place.

Ou est-il un meilleur moyen?

OriginalL'auteur griegs | 2010-04-21

linq

Puisque vous avez un List<T> objet que vous pouvez utiliser ses FindIndex méthode au lieu de Where pour obtenir l'index du premier élément correspondant, plutôt que l'article lui-même:

int index = recommendations.FindIndex(rp =>
                                            rp.Products.Any(p => p.Product.Code == "A") 
                                         && rp.Products.Any(p => p.Product.Code == "B")
                                      );

Une fois que vous avez l'index, vous pouvez obtenir l'élément suivant ou précédent article ou ce que vous voulez.

+1 Pour l'utilisation de lambda de la syntaxe.

OriginalL'auteur EMP

33

Voici ma meilleure méthode:
```
MyList.SkipWhile(item => item.Name != "someName").Skip(1).FirstOrDefault()
```
Une précédente réponse utilise Skip(1).Take(1) qui fonctionne, mais renvoie une liste de résultats. Dans mon cas (et peut-être le cas des OP cas), nous sommes à la recherche de l'élément réel. Donc mon code passe jusqu'à ce qu'il arrive à la personne que nous cherchons (Où serait de retour d'un sous-ensemble si nous n'aurions pas accès à l'élément suivant) puis saute un de plus et devient alors l'élément.

Note: Cette réponse est mentionné dans la Microsoft Virtual Academy cours "démystifier LINQ' - Partie 6

OriginalL'auteur Jeremy Foster

Comment quelque chose comme cela:

public static class Extension
{
    public static T Next<T>(this IEnumerable<T> source, Func<T, bool> predicate)
    {
        bool flag = false;

        using (var enumerator = source.GetEnumerator())
        {
            while (enumerator.MoveNext())
            {
                if (flag) return enumerator.Current;

                if(predicate(enumerator.Current))
                {
                    flag = true;
                }
            }
        }
        return default(T);
    }
}

Vous pouvez l'appeler comme vous le feriez pour Où

Products.Next(x => x.Whatever);

OriginalL'auteur Jim Johnson

5

Essayer celui-ci

Élément SUIVANT
```
MyList.SkipWhile(x => x != value).Skip(1).FirstOrDefault();
```
Élément PRÉCÉDENT remarque:Reverse() ne fonctionnera pas pour LINQ to SQL
```
 var MyList2 = MyList.ToList();
 MyList2.Reverse();
 MyList2.SkipWhile(x => x != value).Skip(1).FirstOrDefault();
```
Je pense que Reverse n'est pas mis en œuvre dans SQL Server.
msdn.microsoft.com/en-us/library/bb358497(v=vs. 110).aspx Il est LINQ et l'Inverse est ici
Oui, c'est LINQ API, mais si c'est LINQ to SQL (Serveur), il va jeter erreur, car il n'y a pas d'équivalence en SQL.
Oui! vous avez raison, il lèvera une erreur en cas de LINQ to SQL.mais je ne pense pas que nous parlons ici de LINQ to SQL. Permettez-moi de modifier ma réponse afin que les gens doivent savoir à ce sujet.

OriginalL'auteur Abdul Saboor

Ce devrait le faire. Je n'ai pas construit un test pour elle en particulier.

var nextProducts = from item1 in recommendations.Select((rec, idx) => new { Rec = rec, Index = idx })
                    join item2 in recommendations.Select((rec, idx) => new { Rec = rec, Index = idx })
                    on item1.Index equals item2.Index - 1
                    where item1.Rec.Products.Any(p => p.Code == "A")
                    && item1.Rec.Products.Any(p => p.Code == "B")
                    select item2.Rec;

Si vous avez besoin de deux dossiers, l'instruction select peut être

select new { MatchingItem = item1.Rec, NextItem = item2.Rec };

Mais alors que vous auriez à faire un groupement pour tenir compte d'un élément correspondant étant le dernier élément de la liste (il n'y aurait pas un élément suivant dans ce cas).

var nextProducts = from item1 in recommendations.Select((rec, idx) => new { Rec = rec, Index = idx })
                    join item2 in recommendations.Select((rec, idx) => new { Rec = rec, Index = idx })
                    on item1.Index equals item2.Index - 1
                    into groupjoin
                    from i2 in groupjoin.DefaultIfEmpty ()
                    where item1.Rec.Products.Any(p => p.Code == "A")
                    && item1.Rec.Products.Any(p => p.Code == "B")
                    select new { MatchingItem = item1.Rec, NextItem = i2 == null ? null : i2.Rec };

Le code que j'ai ne test a été quelque chose de similaire avec une liste de chaînes de caractères.

List<string> list = new List<string>() { "a", "b", "c", "a", "d", "a", "e" };

var query = from item1 in list.Select((s, idx) => new { Item = s, Index = idx })
            join item2 in list.Select((s, idx) => new { Item = s, Index = idx })
            on item1.Index equals item2.Index - 1
            where item1.Item == "a"
            select item2.Item;

Qui renvoie b, d et e.

OriginalL'auteur Anthony Pegram

0

Est l'article 7 qui correspond à vos clause where? Si oui, utiliser la Skip() et Take() les méthodes d'extension:
```
var myProducts =
   from rp in recommendations
   where
      cp.Products.Any(p => p.Product.Code == "A") &&
      cp.Products.Any(p => p.Product.Code == "B")
   select rp;

var nextProduct = myProducts.Skip(1).Take(1);
```
Je ne pense pas que ce sera exactement le travail. Dans la Fpo cas, il semblerait qu'à l'origine, ne renvoie 1 résultat, et ils veulent que le prochain dans la liste d'ORIGINE.
c'est correct. Je veux trouver l'élément correspondant et ensuite de retour à l'élément suivant dans la liste.

OriginalL'auteur spoulson

Vous devez vous connecter pour publier un commentaire.