Existe-t-il une fonction "entre" en C #?

Question

Google ne comprend pas que "entre" est le nom de la fonction que je recherche et ne renvoie rien de pertinent.

Ex: je veux vérifier si 5 est compris entre 0 et 10 en une seule opération

Answer 1

Ce que vous entendez par "une opération" n'est pas clair, mais non, il n'y a pas d'opérateur / méthode d'infrastructure à ma connaissance pour déterminer si un élément est dans une plage.

Vous pouvez bien sûr écrire une méthode d'extension vous-même. Par exemple, en voici un qui suppose que l'intervalle est fermé aux deux extrémités.

 public static bool IsBetween<T>(this T item, T start, T end)
{
    return Comparer<T>.Default.Compare(item, start) >= 0
        && Comparer<T>.Default.Compare(item, end) <= 0;
}
 

Et puis utilisez-le comme:

 bool b = 5.IsBetween(0, 10); // true
 

Answer 2

Non, mais vous pouvez écrire le vôtre:

 public static bool Between(this int num, int lower, int upper, bool inclusive = false)
{
    return inclusive
        ? lower <= num && num <= upper
        : lower < num && num < upper;
}
 

Answer 3

Voici un cours complet.

 /// <summary>
/// An extension class for the between operation
/// name pattern IsBetweenXX where X = I -> Inclusive, X = E -> Exclusive
/// </summary>
public static class BetweenExtensions
{

    /// <summary>
    /// Between check <![CDATA[min <= value <= max]]> 
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value">the value to check</param>
    /// <param name="min">Inclusive minimum border</param>
    /// <param name="max">Inclusive maximum border</param>
    /// <returns>return true if the value is between the min and max else false</returns>
    public static bool IsBetweenII<T>(this T value, T min, T max) where T : IComparable
    {
        return (min.CompareTo(value) <= 0) && (value.CompareTo(max) <= 0);
    }

    /// <summary>
    /// Between check <![CDATA[min <= value <= max]]>
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value">the value to check</param>
    /// <param name="min">Exclusive minimum border</param>
    /// <param name="max">Inclusive maximum border</param>
    /// <returns>return true if the value is between the min and max else false</returns>
    public static bool IsBetweenEI<T>(this T value, T min, T max) where T : IComparable
    {
        return (min.CompareTo(value) < 0) && (value.CompareTo(max) <= 0);
    }

    /// <summary>
    /// between check <![CDATA[min <= value <= max]]>
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value">the value to check</param>
    /// <param name="min">Inclusive minimum border</param>
    /// <param name="max">Exclusive maximum border</param>
    /// <returns>return true if the value is between the min and max else false</returns>
    public static bool IsBetweenIE<T>(this T value, T min, T max) where T : IComparable
    {
        return (min.CompareTo(value) <= 0) && (value.CompareTo(max) < 0);
    }

    /// <summary>
    /// between check <![CDATA[min <= value <= max]]>
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value">the value to check</param>
    /// <param name="min">Exclusive minimum border</param>
    /// <param name="max">Exclusive maximum border</param>
    /// <returns>return true if the value is between the min and max else false</returns>

    public static bool IsBetweenEE<T>(this T value, T min, T max) where T : IComparable
    {
        return (min.CompareTo(value) < 0) && (value.CompareTo(max) < 0);
    }
}
 

plus un code de test unitaire

 [TestClass]
public class UnitTest1
{
    [TestMethod]
    public void TestMethodIsBeetween()
    {
        Assert.IsTrue(5.0.IsBetweenII(5.0, 5.0));
        Assert.IsFalse(5.0.IsBetweenEI(5.0, 5.0));
        Assert.IsFalse(5.0.IsBetweenIE(5.0, 5.0));
        Assert.IsFalse(5.0.IsBetweenEE(5.0, 5.0));

        Assert.IsTrue(5.0.IsBetweenII(4.9, 5.0));
        Assert.IsTrue(5.0.IsBetweenEI(4.9, 5.0));
        Assert.IsFalse(5.0.IsBetweenIE(4.9, 5.0));
        Assert.IsFalse(5.0.IsBetweenEE(4.9, 5.0));

        Assert.IsTrue(5.0.IsBetweenII(5.0, 5.1));
        Assert.IsFalse(5.0.IsBetweenEI(5.0, 5.1));
        Assert.IsTrue(5.0.IsBetweenIE(5.0, 5.1));
        Assert.IsFalse(5.0.IsBetweenEE(5.0, 5.1));

        Assert.IsTrue(5.0.IsBetweenII(4.9, 5.1));
        Assert.IsTrue(5.0.IsBetweenEI(4.9, 5.1));
        Assert.IsTrue(5.0.IsBetweenIE(4.9, 5.1));
        Assert.IsTrue(5.0.IsBetweenEE(4.9, 5.1));

        Assert.IsFalse(5.0.IsBetweenII(5.1, 4.9));
        Assert.IsFalse(5.0.IsBetweenEI(5.1, 4.9));
        Assert.IsFalse(5.0.IsBetweenIE(5.1, 4.9));
        Assert.IsFalse(5.0.IsBetweenEE(5.1, 4.9));

    }
}
 

Answer 4

Non, vous devrez tester chaque point d'extrémité individuellement.

 if ((x > 0) && (x < 10)) {
   // do stuff
}
 

Ou si vous voulez qu'il ait l' air plus "entre deux", réorganisez les arguments:

 if ((0 < x) && (x < 10)) {
   // do stuff
}
 

Answer 5

Jusqu'à présent, il semble qu'aucune des réponses n'ait envisagé la possibilité que, de manière dynamique, vous ne sachiez pas quelle valeur correspond aux limites inférieure et supérieure. Pour le cas général, vous pouvez créer votre propre méthode IsBetween qui ressemblerait probablement à ceci:

     public bool IsBetween(double testValue, double bound1, double bound2)
    {
        return (testValue >= Math.Min(bound1,bound2) && testValue <= Math.Max(bound1,bound2));
    }