"in" expression for comparing multiple values

[CypherPotato]

Motivation

A common need I've had for some time is to check whether a value is part of a set, directly comparing whether the object is equal to something belonging to the set.

Since the .NET Framework, I have been using something similar to:

int value = 20;

if (new int[] { 10, 20, 30 }.Contains(value)) {
    // the specified set contains the value
}

In a recent project, I've extended an In<T> method that does the same comparison, but in a slightly more elegant way and eliminates the need to allocate an array to the set:

public static bool In<T>(this T value, params T[] values)
{
    foreach (T source in values)
    {
        if (source.Equals(value))
        {
            return true;
        }
    }
    return false;
}

And the usage:

Level level = Level.Administrator;

if (level.In(Level.Administrator, Level.Manager))
{
    Console.WriteLine("User is administrator or manager!");
}
else
{
    Console.WriteLine("Access danied");
}

Syntax

But, I wonder if a syntax-sugar could reduce the direct code in compilation, where the suggested use of the in operator together with a collection expression, like:

if (level in [Level.Administrator, Level.Manager]) {
    // do something
}

if (level not in [Level.Administrator, Level.Manager]) {
    // negation of above condition
}

Would be the reduced equivalent to:

if ((level.Equals(Level.Administrator) || level.Equals(Level.Manager))) {
    // do something
}

if ( (!level.Equals(Level.Administrator) && !level.Equals(Level.Manager)) ) {
    // negation
}

Concerns

• Objects would always be compared with their Equals set to their common type. It would not be possible to use abstractions of different types as it could give confusing results because each type implements its own Equals. Therefore, if the value being compared is of type Foo, it will use Foo.Equals for each object present in the set.

Alternatives

I don't see any other than defining the method In<T> itself or doing several foo == bar || foo == daz ....

[HaloFour]

You can use disjunctive patterns (or):

if (value is 10 or 20 or 30) { }

if (level is Level.Administrator or Level.Manager) { }

[CypherPotato]

I didn't know that was a thing. It seems like it meets the need.

[FaustVX]

That works very well, but only for constants.

[CypherPotato]

Yea, it would'nt work for an array of instanced objects by the way, like:

if (user is user1 or user2) // compilation error

So, maybe we could work with

user == user1 or user 2 // ok

which is the equivalent to

user == user1 || user == user 2

[CypherPotato]

To talk about this, I've opened this issue. I'll close this issue for now.

[FaustVX]

In a recent project, I've extended an In<T> method that does the same comparison, but in a slightly more elegant way and eliminates the need to allocate an array to the set:

public static bool In<T>(this T value, params T[] values)
{
    foreach (T source in values)
    {
        if (source.Equals(value))
        {
            return true;
        }
    }
    return false;
}

In your example, you said that you don't allocate an array but you are allocating an array for T[] values

[CypherPotato]

I once heard that params array[] does not allocate an array but creates one from the given references without allocating them again. Idk if true btw.

[FaustVX]

Maybe, if the array can be a "constant", the JIT can optimise it, but otherwise, I don't think so.

[KennethHoff]

In C# 13 this will be "allocation free" (read: only on the stack) by using params ReadOnlySpan instead