c# Trouver de la valeur dans une plage à l'aide lambda

J'essaie de trouver un élément dans une liste de valeurs basée sur une autre valeur à l'aide d'une expression lambda à l'aide de la méthode Find. Dans cet exemple, je m'attends à revenir -1000, mais pour la vie de moi, je ne peux pas venir avec le bon lamda expression. Si cela vous semble confus, je l'espère, le code et les commentaires en dessous de l'expliquer mieux.
TIA.

using System;
using System.Collections.Generic;

namespace TestingStuff {
    class Program {
        static void Main(string[] args) {
            double amount = -200;

            //The Range of values
            List<MyValue> values = new List<MyValue>();
            values.Add(new MyValue(-1000));
            values.Add(new MyValue(-100));
            values.Add(new MyValue(-10));
            values.Add(new MyValue(0));
            values.Add(new MyValue(100));
            values.Add(new MyValue(1000));

            //Find it!!!  
            MyValue fVal = values.Find(x => (x.Value > amount) && (x.Value < amount));

            //Expecting -1000 as a result here since -200 falls between -1000 and -100
            //if it were -90 I'd expect -100 since it falls between -100 and 0
            if (fVal != null)
                Console.WriteLine(fVal.Value);            
            Console.ReadKey();
        }
    }

    public class MyValue {
        public double Value { get; set; }
        public MyValue(double value) {
            Value = value;
        }        
    }
}

Mmm permettez-moi de mettre mes intentions un peu plus clair en précisant les résultats attendus.

-1000 et moins à -101 devrait donner -1000
-100 à - 11 devrait donner -100
-10 -1 devrait donner -10
De 0 à 9 doit donner 0
De 10 à 99 devrait donner 10
100-999 doit se donner à 100
1000 ou plus devrait donner 1000

Si vous utilisez +200, qu'attendez-vous?
Si vous utilisez -100, ne vous attendez -1000 ou -100 comme un résultat?

OriginalL'auteur n4rzul | 2010-05-21

c#find list range

8

Cela devrait fonctionner:
```
values.FindLast(x => amount >= x.Value);
```
Génial c'est percect. Comment élégant!
Tenez-vous bien, peut-être pas à 100% ce qui convient à tous l'exemple même 10000000 qui devrait donner 1000 mais il ne pourvoit pas à -100000 qui devrait donner à -1000. Je pourrais juste ajouter une très très grande valeur négative pour le début de ma liste, mais il devrait fonctionner correctement.

OriginalL'auteur Julien Lebosquain
2

Vous avez fait une erreur logique ... une valeur ne peut pas être > -200 ET < -200 à la même période de temps .. U ont besoin de la OU d'une expression ( "||" )
```
 MyValue fVal = values.Find(x => (x.Value > amount) || (x.Value < amount));
```
Mais si vous vous attendez à obtenir -1000 cette expression est aussi mauvais
```
 MyValue fVal = values.Find(x => (x.Value < amount));
```
Parce que -1000 est inférieure à -200

EDIT : Ok je pense que-je missunderstood votre intention. Mais la façon dont vous souhaitez sélectionner votre valeur ne semble pas logique pour moi. Voulez-vous la prochaine plus petite valeur ?

J'ai mis à jour la question principale, avec tous les résultats escomptés. Veuillez voir là. Ce qui en gros, je veux, c'est faire un entre comme vous le feriez dans une instruction SQL lors de la recherche pour des résultats qui se situent entre deux dates à l'exception de ces numéros. Par exemple: SELECT * from Users where CreationDate > '2010-03-01" ET CreationDate < '2010-03-31', Qui trouve tous les utilisateurs entre le 1er mars et le 31 mars. Espérons que cela a du sens

OriginalL'auteur KroaX
1

Je suis en train de faire l'hypothèse que si vous avez utilisé la valeur de +90, vous vous attendez à 100 et non pas à zéro, ainsi que si vous utilisez 200, vous vous attendez à avoir 1000 et des 100.
```
MyValue fVal = values
    .Where(x => amount > 0 ? x.Value > amount : x.Value < amount)
    .OrderBy(x => amount > 0 ? x.Value : -x.Value).First();
```
nope, inverse

OriginalL'auteur Darksider
0

Faire la même hypothèse que Darksider une Autre option serait
```
MyValue fVal = values.Find(x => Math.Abs(x.Value) > amount && (x.Value<0 == amount<0));
```
bien sûr, cela s'appuie sur la liste déjà triée. Darksider la solution peut être mieux si la liste ne soient pas classés alreday.

Julien fonctionne correctement dans mon cas, sauf pour de très petites valeurs négatives. Je vais juste ajouter une très petite valeur négative dans la liste et tout devrait être bon.

OriginalL'auteur Joe Simmonds

Vous devez vous connecter pour publier un commentaire.