How to elegantly check if a number is within a range?

Question

How can I do this elegantly with C# and .Net 3.5/4?

For example a number can be between 1 and 100.

Edit: I know a simple if would suffice; but the keyword to this question is elegance. It's for my toy project not for production.

Edit 2: This questions wasn't about speed but about code beauty. Stop talking about efficiency and such; remember you're preaching to the choir.

Answer 1

You mean?

if(number > 1 && number < 100)

or

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

Answer 2

A new twist on an old favorite:

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

Answer 3

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

Answer 4

This is a real simple one. Doesnt have to be more elagant than an if statement. dont try to get too fancy. Never sacrifice simplicity for elegance.

Answer 5

Just to add to the noise here, you could create an extension method:

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

Which would let you do something like...

int val = 15;

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

That being said, this seems like a silly thing to do when the check itself is only one line.

Answer 6

There are a lot of options:

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

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

Also, check out this SO post for regex options.

Answer 7

If this is incidental, a simple if is all you need. If this happens in many places, you might want to consider these two:

• PostSharp. Decorate methods with attributes that 'inject' code into the method after compilation. I don't know for sure, but I can imagine it can be used for this.

Something like:

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

• Code contracts. Has the advantage that the constraints can be checked at compile time, by static verification of your code and the places that use your code.

Answer 8

(1 < value) ? (value < 100) : false;

By "Elegant", do you mean "intentionally difficult to read"?

Edit: Here's a more elegant solution.

new Rectangle(min, 1, max, 1).IntersectsWith(new Rectangle(value, 1, 1, 1));

Answer 9

As others said, use a simple if.

You should think about the ordering.

e.g

1 <= x && x <= 100

is easier to read than

x => 1 && x <= 100

Answer 10

In C, if time efficiency is crucial and integer overflows will wrap, one could do "if ((unsigned)(value-min) <= (max-min)) ...". If 'max' and 'min' are independent variables, the extra subtraction for (max-min) will waste time, but if that expression can be precomputed at compile time, or if it can be computed once at run-time to test many numbers against the same range, the above expression may be computed efficiently even in the case where the value is within range (if a large fraction of values will be below the valid range, it may be faster to use "if ((value >= min) && (value <= max)) ..." because it will "exit early" if value is less than min).

Before using an implementation like that, though, benchmark one one's target machine. On some processors, the two-part expression may be faster in all cases since the two comparisons may be done independently whereas in the subtract-and-compare method the subtraction has to complete before the compare can execute.

Answer 11

With a bit of extension method abuse, we can get the following "elegant" solution:

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!");
        }
    }
}

Answer 12

Using an && expression to join two comparisons is simply the most elegant way to do this. If you try using fancy extension methods and such, you run into the question of whether to include the upper bound, the lower bound, or both. Once you start adding additional variables or changing the extension names to indicate what is included, your code becomes longer and harder to read (for the vast majority of programmers). Furthermore, tools like Resharper will warn you if your comparison doesn't make sense (number > 100 && number < 1), which they won't do if you use a method ('i.IsBetween(100, 1)').

The only other comment I'd make is that if you're checking inputs with the intention to throw an exception, you should consider using code contracts:

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

This is more elegant than if(...) throw new Exception(...), and you could even get compile-time warnings if someone tries to call your method without ensuring that the number is in bounds first.