Comment vérifier avec élégance si un nombre se trouve dans une plage?

Comment puis-je faire cela avec élégance avec C # et .NET 3.5 / 4?

Par exemple, un nombre peut être compris entre 1 et 100.

Je sais qu'un simple si suffirait; mais le mot clé de cette question est l'élégance. C'est pour mon projet de jouet pas pour la production.

Ces questions ne concernaient pas la vitesse, mais la beauté du code. Arrêtez de parler d'efficacité et autres; souvenez-vous que vous prêchez à la chorale.

Il existe de nombreuses options:

int x = 30;
if (Enumerable.Range(1,100).Contains(x))
    //true

if (x >= 1 && x <= 100)
    //true

Consultez également cet article SO pour les options de regex.

Tu veux dire?

if(number >= 1 && number <= 100)

ou

bool TestRange (int numberToCheck, int bottom, int top)
{
  return (numberToCheck >= bottom && numberToCheck <= top);
}

Juste pour ajouter au bruit ici, vous pouvez créer une méthode d'extension:

public static bool IsWithin(this int value, int minimum, int maximum)
{
    return value >= minimum && value <= maximum;
}

Ce qui vous permettrait de faire quelque chose comme ...

int val = 15;

bool foo = val.IsWithin(5,20);

Cela étant dit, cela semble être une chose idiote à faire lorsque le chèque lui-même n'est qu'une ligne.

Comme d'autres l'ont dit, utilisez un simple if.

Vous devriez penser à la commande.

par exemple

1 <= x && x <= 100

est plus facile à lire que

x >= 1 && x <= 100

Dans le code de production, j'écrirais simplement

1 <= x && x <= 100

C'est facile à comprendre et très lisible.

Voici une méthode intelligente qui réduit le nombre de comparaisons de deux à un en utilisant des mathématiques. L'idée est que l'un des deux facteurs devient négatif si le nombre se situe en dehors de la plage et zéro si le nombre est égal à l'une des bornes:

Si les limites sont inclusives:

(x - 1) * (100 - x) >= 0

ou

(x - min) * (max - x) >= 0

Si les limites sont exclusives:

(x - 1) * (100 - x) > 0

ou

(x - min) * (max - x) > 0

Je propose ceci:

public static bool IsWithin<T>(this T value, T minimum, T maximum) where T : IComparable<T> {
    if (value.CompareTo(minimum) < 0)
       return false;
    if (value.CompareTo(maximum) > 0)
       return false;
    return true;
}

Exemples:

45.IsWithin(32, 89)
true
87.2.IsWithin(87.1, 87.15)
false
87.2.IsWithin(87.1, 87.25)
true

et bien sûr avec des variables:

myvalue.IsWithin(min, max)

Il est facile à lire (proche du langage humain) et fonctionne avec tout type comparable (entiers, doubles, types personnalisés ...).

Avoir un code facile à lire est important car le développeur ne perdra pas de «cycles cérébraux» pour le comprendre. Dans les longues sessions de codage, les cycles cérébraux gaspillés rendent le développeur fatigué plus tôt et sujet aux bogues.

Avec un peu d'abus de méthode d'extension, nous pouvons obtenir la solution «élégante» suivante:

using System;

namespace Elegant {
    public class Range {
        public int Lower { get; set; }
        public int Upper { get; set; }
    }

    public static class Ext {
        public static Range To(this int lower, int upper) {
            return new Range { Lower = lower, Upper = upper };
        }

        public static bool In(this int n, Range r) {
            return n >= r.Lower && n <= r.Upper;
        }
    }

    class Program {
        static void Main() {
            int x = 55;
            if (x.In(1.To(100)))
                Console.WriteLine("it's in range! elegantly!");
        }
    }
}

Si c'est accidentel, un simple ifest tout ce dont vous avez besoin. Si cela se produit dans de nombreux endroits, vous voudrez peut-être considérer ces deux éléments:

• PostSharp . Décorez les méthodes avec des attributs qui «injectent» du code dans la méthode après la compilation. Je ne sais pas avec certitude, mais je peux imaginer qu'il peut être utilisé pour cela.

Quelque chose comme:

[Between("parameter", 0, 100)]
public void Foo(int parameter)
{
}

• Contrats de code . A l'avantage que les contraintes peuvent être vérifiées au moment de la compilation, par vérification statique de votre code et des endroits qui utilisent votre code.

if (value > 1 && value < 100)
{
    // do work
}
else
{
    // handle outside of range logic
}

Utiliser une &&expression pour joindre deux comparaisons est simplement la manière la plus élégante de le faire. Si vous essayez d'utiliser des méthodes d'extension sophistiquées et autres, vous vous demandez s'il faut inclure la limite supérieure, la limite inférieure ou les deux. Une fois que vous commencez à ajouter des variables supplémentaires ou à modifier les noms d'extension pour indiquer ce qui est inclus, votre code devient plus long et plus difficile à lire (pour la grande majorité des programmeurs). De plus, des outils comme Resharper vous avertiront si votre comparaison n'a pas de sens ( number > 100 && number < 1), ce qu'ils ne feront pas si vous utilisez une méthode ('i.IsB Between (100, 1)').

Le seul autre commentaire que je ferais est que si vous vérifiez les entrées avec l'intention de lever une exception, vous devriez envisager d'utiliser des contrats de code:

Contract.Requires(number > 1 && number < 100)

C'est plus élégant que if(...) throw new Exception(...), et vous pouvez même obtenir des avertissements lors de la compilation si quelqu'un essaie d'appeler votre méthode sans vous assurer que le nombre est dans les limites en premier.

Si vous voulez écrire plus de code qu'un simple if, vous pouvez peut-être: Créer une méthode d'extension appelée IsBetween

public static class NumberExtensionMethods
{
    public static bool IsBetween(this long value, long Min, long Max)
    {
        // return (value >= Min && value <= Max);
        if (value >= Min && value <= Max) return true;
        else return false;
    }
}

...

// Checks if this number is between 1 and 100.
long MyNumber = 99;
MessageBox.Show(MyNumber.IsBetween(1, 100).ToString());

Addenda:il est intéressant de noter que dans la pratique, vous ne "vérifiez que l'égalité" (ou <,>) dans une base de code. (Sauf dans les situations les plus triviales.) À titre d'exemple, tout programmeur de jeu utiliserait des catégories quelque chose comme ce qui suit dans chaque projet, comme une question de base. Notez que dans cet exemple, il utilise (se trouve être) une fonction (Mathf.Approximately) qui est intégrée à cet environnement; dans la pratique, vous devez généralement développer soigneusement vos propres concepts sur ce que les comparaisons signifient pour les représentations informatiques de nombres réels, pour le type de situation que vous concevez. (Ne dites même pas que si vous faites quelque chose comme, peut-être un contrôleur, un contrôleur PID ou autre, tout le problème devient central et très difficile, cela devient la nature du projet.

private bool FloatLessThan(float a, float b)
    {
    if ( Mathf.Approximately(a,b) ) return false;
    if (a<b) return true;
    return false;
    }

private bool FloatLessThanZero(float a)
    {
    if ( Mathf.Approximately(a,0f) ) return false;
    if (a<0f) return true;
    return false;
    }

private bool FloatLessThanOrEqualToZero(float a)
    {
    if ( Mathf.Approximately(a,0f) ) return true;
    if (a<0f) return true;
    return false;
    }

Parce que toutes les autres réponses ne sont pas inventées par moi, voici juste ma mise en œuvre:

public enum Range
{
    /// <summary>
    /// A range that contains all values greater than start and less than end.
    /// </summary>
    Open,
    /// <summary>
    /// A range that contains all values greater than or equal to start and less than or equal to end.
    /// </summary>
    Closed,
    /// <summary>
    /// A range that contains all values greater than or equal to start and less than end.
    /// </summary>
    OpenClosed,
    /// <summary>
    /// A range that contains all values greater than start and less than or equal to end.
    /// </summary>
    ClosedOpen
}

public static class RangeExtensions
{
    /// <summary>
    /// Checks if a value is within a range that contains all values greater than start and less than or equal to end.
    /// </summary>
    /// <param name="value">The value that should be checked.</param>
    /// <param name="start">The first value of the range to be checked.</param>
    /// <param name="end">The last value of the range to be checked.</param>
    /// <returns><c>True</c> if the value is greater than start and less than or equal to end, otherwise <c>false</c>.</returns>
    public static bool IsWithin<T>(this T value, T start, T end) where T : IComparable<T>
    {
        return IsWithin(value, start, end, Range.ClosedOpen);
    }

    /// <summary>
    /// Checks if a value is within the given range.
    /// </summary>
    /// <param name="value">The value that should be checked.</param>
    /// <param name="start">The first value of the range to be checked.</param>
    /// <param name="end">The last value of the range to be checked.</param>
    /// <param name="range">The kind of range that should be checked. Depending on the given kind of range the start end end value are either inclusive or exclusive.</param>
    /// <returns><c>True</c> if the value is within the given range, otherwise <c>false</c>.</returns>
    public static bool IsWithin<T>(this T value, T start, T end, Range range) where T : IComparable<T>
    {
        if (value == null)
            throw new ArgumentNullException(nameof(value));

        if (start == null)
            throw new ArgumentNullException(nameof(start));

        if (end == null)
            throw new ArgumentNullException(nameof(end));

        switch (range)
        {
            case Range.Open:
                return value.CompareTo(start) > 0
                       && value.CompareTo(end) < 0;
            case Range.Closed:
                return value.CompareTo(start) >= 0
                       && value.CompareTo(end) <= 0;
            case Range.OpenClosed:
                return value.CompareTo(start) > 0
                       && value.CompareTo(end) <= 0;
            case Range.ClosedOpen:
                return value.CompareTo(start) >= 0
                       && value.CompareTo(end) < 0;
            default:
                throw new ArgumentException($"Unknown parameter value {range}.", nameof(range));
        }
    }
}

Vous pouvez ensuite l'utiliser comme ceci:

var value = 5;
var start = 1;
var end = 10;

var result = value.IsWithin(start, end, Range.Closed);

MODIFIER: Nouvelle réponse fournie. Je commençais à peine à utiliser C # lorsque j'ai écrit la première réponse à cette question, et avec le recul je me rends compte maintenant que ma «solution» était / est naïve et inefficace.

Ma réponse originale: j'irais avec la version la plus simple:

if(Enumerable.Range(1,100).Contains(intInQuestion)) { ...DoStuff; }

Une meilleure façon

Comme je n'ai vu aucune autre solution plus efficace (au moins d'après mes tests), je vais essayer de nouveau.

Nouvelle et meilleure méthode qui fonctionne également avec des plages négatives :

// Returns true if x is in range [min..max], else false 
bool inRange(int x, int min=1, int max=100) => ((x - max)*(x - min) <= 0);

Cela peut être utilisé avec des plages positives et négatives et par défaut sur une plage de

1..100 (inclus) et utilise xcomme nombre à vérifier suivi d'une plage facultative définie par minet max.

Ajouter des exemples pour une bonne mesure

Exemple 1:

// Returns true if x is in range [min..max], else false 
bool inRange(int x, int min=1, int max=100) => ((x - max)*(x - min) <= 0);

Console.WriteLine(inRange(25));
Console.WriteLine(inRange(1));
Console.WriteLine(inRange(100));
Console.WriteLine(inRange(25, 30, 150));
Console.WriteLine(inRange(-25, -50, 0));

Retour:

True
True
True
False
True

Exemple 2: Utilisation d'une liste de nombres entiers aléatoires entre 1 et 150

// Returns true if x is in range [min..max], else false 
bool inRange(int x, int min=1, int max=100) => ((x - max)*(x - min) <= 0);

// Generate 100000 ints between 1 and 150
var intsToCheck = new List<int>();
var randGen = new Random();
for(int i = 0; i < 100000; ++i){
    intsToCheck.Add(randGen.Next(150) + 1);
}

var counter = 0;
foreach(int n in intsToCheck) {
    if(inRange(n)) ++counter;
}

Console.WriteLine("{0} ints found in range 1..100", counter);

Retour:

66660 ints found in range 1..100

Temps d'exécution: 0.016 seconde (s)

Une nouvelle tournure sur un vieux favori:

public bool IsWithinRange(int number, int topOfRange, int bottomOfRange, bool includeBoundaries) {
    if (includeBoundaries)
        return number <= topOfRange && number >= bottomOfRange;
    return number < topOfRange && number > bottomOfRange;
}

En C, si l'efficacité du temps est cruciale et que les débordements d'entiers seront bouclés, on pourrait le faire if ((unsigned)(value-min) <= (max-min)) .... Si 'max' et 'min' sont des variables indépendantes, la soustraction supplémentaire pour (max-min) perdra du temps, mais si cette expression peut être précalculée au moment de la compilation, ou si elle peut être calculée une fois au moment de l'exécution pour en tester plusieurs nombres par rapport à la même plage, l'expression ci-dessus peut être calculée efficacement même dans le cas où la valeur est dans la plage (si une grande fraction de valeurs sera inférieure à la plage valide, il peut être plus rapide à utiliserif ((value >= min) && (value <= max)) ... car elle se terminera tôt si value est inférieure à min).

Avant d'utiliser une telle implémentation, cependant, comparez la machine cible d'une personne. Sur certains processeurs, l'expression en deux parties peut être plus rapide dans tous les cas puisque les deux comparaisons peuvent être effectuées indépendamment alors que dans la méthode de soustraction et de comparaison, la soustraction doit être terminée avant que la comparaison puisse s'exécuter.

Que diriez-vous quelque chose comme ça?

if (theNumber.isBetween(low, high, IntEx.Bounds.INCLUSIVE_INCLUSIVE))
{
}

avec la méthode d'extension comme suit (testé):

public static class IntEx
{
    public enum Bounds 
    {
        INCLUSIVE_INCLUSIVE, 
        INCLUSIVE_EXCLUSIVE, 
        EXCLUSIVE_INCLUSIVE, 
        EXCLUSIVE_EXCLUSIVE
    }

    public static bool isBetween(this int theNumber, int low, int high, Bounds boundDef)
    {
        bool result;
        switch (boundDef)
        {
            case Bounds.INCLUSIVE_INCLUSIVE:
                result = ((low <= theNumber) && (theNumber <= high));
                break;
            case Bounds.INCLUSIVE_EXCLUSIVE:
                result = ((low <= theNumber) && (theNumber < high));
                break;
            case Bounds.EXCLUSIVE_INCLUSIVE:
                result = ((low < theNumber) && (theNumber <= high));
                break;
            case Bounds.EXCLUSIVE_EXCLUSIVE:
                result = ((low < theNumber) && (theNumber < high));
                break;
            default:
                throw new System.ArgumentException("Invalid boundary definition argument");
        }
        return result;
    }
}

Je ferais un objet Range, quelque chose comme ceci:

public class Range<T> where T : IComparable
{
    public T InferiorBoundary{get;private set;}
    public T SuperiorBoundary{get;private set;}

    public Range(T inferiorBoundary, T superiorBoundary)
    {
        InferiorBoundary = inferiorBoundary;
        SuperiorBoundary = superiorBoundary;
    }

    public bool IsWithinBoundaries(T value){
        return InferiorBoundary.CompareTo(value) > 0 && SuperiorBoundary.CompareTo(value) < 0;
    }
}

Ensuite, vous l'utilisez de cette façon:

Range<int> myRange = new Range<int>(1,999);
bool isWithinRange = myRange.IsWithinBoundaries(3);

De cette façon, vous pouvez le réutiliser pour un autre type.

Lorsque vous vérifiez si un «nombre» est dans une plage, vous devez être clair dans ce que vous voulez dire, et que signifie deux nombres égaux? En général, vous devriez envelopper tous les nombres à virgule flottante dans ce qu'on appelle une «boule epsilon». Ceci est fait en choisissant une petite valeur et en disant que si deux valeurs sont si proches, elles sont la même chose.

    private double _epsilon = 10E-9;
    /// <summary>
    /// Checks if the distance between two doubles is within an epsilon.
    /// In general this should be used for determining equality between doubles.
    /// </summary>
    /// <param name="x0">The orgin of intrest</param>
    /// <param name="x"> The point of intrest</param>
    /// <param name="epsilon">The minimum distance between the points</param>
    /// <returns>Returns true iff x  in (x0-epsilon, x0+epsilon)</returns>
    public static bool IsInNeghborhood(double x0, double x, double epsilon) => Abs(x0 - x) < epsilon;

    public static bool AreEqual(double v0, double v1) => IsInNeghborhood(v0, v1, _epsilon);

Avec ces deux aides en place et en supposant que si un nombre quelconque peut être moulé en double sans la précision requise. Tout ce dont vous aurez besoin maintenant est une énumération et une autre méthode

    public enum BoundType
    {
        Open,
        Closed,
        OpenClosed,
        ClosedOpen
    }

L'autre méthode suit:

    public static bool InRange(double value, double upperBound, double lowerBound, BoundType bound = BoundType.Open)
    {
        bool inside = value < upperBound && value > lowerBound;
        switch (bound)
        {
            case BoundType.Open:
                return inside;
            case BoundType.Closed:
                return inside || AreEqual(value, upperBound) || AreEqual(value, lowerBound); 
            case BoundType.OpenClosed:
                return inside || AreEqual(value, upperBound);
            case BoundType.ClosedOpen:
                return inside || AreEqual(value, lowerBound);
            default:
                throw new System.NotImplementedException("You forgot to do something");
        }
    }

Maintenant, c'est peut-être bien plus que ce que vous vouliez, mais cela vous empêche de traiter d'arrondi tout le temps et d'essayer de vous rappeler si une valeur a été arrondie et à quel endroit. Si vous en avez besoin, vous pouvez facilement l'étendre pour fonctionner avec n'importe quel epsilon et permettre à votre epsilon de changer.

static class ExtensionMethods
{
    internal static bool IsBetween(this double number,double bound1, double bound2)
    {
        return Math.Min(bound1, bound2) <= number && number <= Math.Max(bound2, bound1);
    }

    internal static bool IsBetween(this int number, double bound1, double bound2)
    {
        return Math.Min(bound1, bound2) <= number && number <= Math.Max(bound2, bound1);
    }
}

Usage

double numberToBeChecked = 7;

var result = numberToBeChecked.IsB Between (100.122);

var result = 5.IsB Between (100,120);

résultat var = 8,0.IsB Between (1,2,9,6);

Si vous êtes préoccupé par le commentaire de @Daap sur la réponse acceptée et que vous ne pouvez transmettre la valeur qu'une seule fois, vous pouvez essayer l'une des solutions suivantes

bool TestRangeDistance (int numberToCheck, int bottom, int distance)
{
  return (numberToCheck >= bottom && numberToCheck <= bottom+distance);
}

//var t = TestRangeDistance(10, somelist.Count()-5, 10);

ou

bool TestRangeMargin (int numberToCheck, int target, int margin)
{
  return (numberToCheck >= target-margin && numberToCheck <= target+margin);
}

//var t = TestRangeMargin(10, somelist.Count(), 5);

Concernant l'élégance, le plus proche de la notation mathématique ( a <= x <= b ) améliore légèrement la lisibilité:

public static bool IsBetween(this int value, int min, int max)
{
    return min <= value && value <= max;
}

Pour plus d'illustration:

public static bool IsOutside(this int value, int min, int max)
{
    return value < min || max < value;
}

Je cherchais une manière élégante de le faire où les limites pourraient être commutées (c'est-à-dire pas sûr de l'ordre dans lequel les valeurs sont).

Cela ne fonctionnera que sur les versions plus récentes de C # où le?: Existe

bool ValueWithinBounds(float val, float bounds1, float bounds2)
{
    return bounds1 >= bounds2 ?
      val <= bounds1 && val >= bounds2 : 
      val <= bounds2 && val >= bounds1;
}

Évidemment, vous pouvez modifier les signes = pour vos besoins. Pourrait aussi avoir de la fantaisie avec le casting de type. J'avais juste besoin d'un retour flottant dans les limites (ou égal à)

Élégant car il ne vous oblige pas à déterminer laquelle des deux valeurs limites est la plus élevée en premier. Il ne contient pas non plus de branches.

public static bool InRange(float val, float a, float b)
{
    // Determine if val lies between a and b without first asking which is larger (a or b)
    return ( a <= val & val < b ) | ( b <= val & val < a );
}

Je ne sais pas mais j'utilise cette méthode:

    public static Boolean isInRange(this Decimal dec, Decimal min, Decimal max, bool includesMin = true, bool includesMax = true ) {

    return (includesMin ? (dec >= min) : (dec > min)) && (includesMax ? (dec <= max) : (dec < max));
}

Et voici comment je peux l'utiliser:

    [TestMethod]
    public void IsIntoTheRange()
    {
        decimal dec = 54;

        Boolean result = false;

        result = dec.isInRange(50, 60); //result = True
        Assert.IsTrue(result);

        result = dec.isInRange(55, 60); //result = False
        Assert.IsFalse(result);

        result = dec.isInRange(54, 60); //result = True
        Assert.IsTrue(result);

        result = dec.isInRange(54, 60, false); //result = False
        Assert.IsFalse(result);

        result = dec.isInRange(32, 54, false, false);//result = False
        Assert.IsFalse(result);

        result = dec.isInRange(32, 54, false);//result = True
        Assert.IsTrue(result);
    }

Voici quelques méthodes d'extension qui peuvent aider

  public static bool IsInRange<T>(this T value, T min, T max)
where T : System.IComparable<T>
    {
        return value.IsGreaterThenOrEqualTo(min) && value.IsLessThenOrEqualTo(max);
    }


    public static bool IsLessThenOrEqualTo<T>(this T value, T other)
         where T : System.IComparable<T>
    {
        var result = value.CompareTo(other);
        return result == -1 || result == 0;
    }


    public static bool IsGreaterThenOrEqualTo<T>(this T value, T other)
         where T : System.IComparable<T>
    {
        var result = value.CompareTo(other);
        return result == 1 || result == 0;
    }

Si c'est pour valider les paramètres de méthode, aucune des solutions ne lève ArgumentOutOfRangeException et permet une configuration facile / correcte des valeurs min / max inclusives / exclusives.

Utilisez comme ça

public void Start(int pos)
{
    pos.CheckRange(nameof(pos), min: 0);

    if (pos.IsInRange(max: 100, maxInclusive: false))
    {
        // ...
    }
}

Je viens d'écrire ces belles fonctions. Il a également l'avantage de ne pas avoir de branchement (un seul if) pour les valeurs valides. Le plus difficile est de créer les bons messages d'exception.

/// <summary>
/// Returns whether specified value is in valid range.
/// </summary>
/// <typeparam name="T">The type of data to validate.</typeparam>
/// <param name="value">The value to validate.</param>
/// <param name="min">The minimum valid value.</param>
/// <param name="minInclusive">Whether the minimum value is valid.</param>
/// <param name="max">The maximum valid value.</param>
/// <param name="maxInclusive">Whether the maximum value is valid.</param>
/// <returns>Whether the value is within range.</returns>
public static bool IsInRange<T>(this T value, T? min = null, bool minInclusive = true, T? max = null, bool maxInclusive = true)
    where T : struct, IComparable<T>
{
    var minValid = min == null || (minInclusive && value.CompareTo(min.Value) >= 0) || (!minInclusive && value.CompareTo(min.Value) > 0);
    var maxValid = max == null || (maxInclusive && value.CompareTo(max.Value) <= 0) || (!maxInclusive && value.CompareTo(max.Value) < 0);
    return minValid && maxValid;
}

/// <summary>
/// Validates whether specified value is in valid range, and throws an exception if out of range.
/// </summary>
/// <typeparam name="T">The type of data to validate.</typeparam>
/// <param name="value">The value to validate.</param>
/// <param name="name">The name of the parameter.</param>
/// <param name="min">The minimum valid value.</param>
/// <param name="minInclusive">Whether the minimum value is valid.</param>
/// <param name="max">The maximum valid value.</param>
/// <param name="maxInclusive">Whether the maximum value is valid.</param>
/// <returns>The value if valid.</returns>
public static T CheckRange<T>(this T value, string name, T? min = null, bool minInclusive = true, T? max = null, bool maxInclusive = true)
where T : struct, IComparable<T>
{
    if (!value.IsInRange(min, minInclusive, max, maxInclusive))
    {
        if (min.HasValue && minInclusive && max.HasValue && maxInclusive)
        {
            var message = "{0} must be between {1} and {2}.";
            throw new ArgumentOutOfRangeException(name, value, message.FormatInvariant(name, min, max));
        }
        else
        {
            var messageMin = min.HasValue ? GetOpText(true, minInclusive).FormatInvariant(min) : null;
            var messageMax = max.HasValue ? GetOpText(false, maxInclusive).FormatInvariant(max) : null;
            var message = (messageMin != null && messageMax != null) ?
                "{0} must be {1} and {2}." :
                "{0} must be {1}.";
            throw new ArgumentOutOfRangeException(name, value, message.FormatInvariant(name, messageMin ?? messageMax, messageMax));
        }
    }
    return value;
}

private static string GetOpText(bool greaterThan, bool inclusive)
{
    return (greaterThan && inclusive) ? "greater than or equal to {0}" :
        greaterThan ? "greater than {0}" :
        inclusive ? "less than or equal to {0}" :
        "less than {0}";
}

public static string FormatInvariant(this string format, params object?[] args) => string.Format(CultureInfo.InvariantCulture, format, args);

Vous cherchez in [1..100]? Ce n'est que Pascal.