syntactic sugar for checking equality with multiple value

Question

I would like to compare 2 equations, lets say 2*2 and 2+2 to a single answer, 4, using Visual Studio 2015, e.g.

if (4 == (2*2 && 2+2)) {...}

but it returns an error, "Operator '&&' cannot be applied to operands of type 'int' and 'int'". The only other way I could think of writing the code is:

if (4 == 2*2 && 4 == 2+2) {...}

which would work, but gets very repetitive when a lot of values are to be compared. Is there a easier way to achieve this?

Answer 1

var results = new[]{ 2 + 2, 2 * 2, ... };
if (results.All(r => r == 4)) {
    ...
}

This gathers the results of all operations in the collection results, and uses the extension method All to verify that the specified predicate holds for all values; allowing to write the predicate only once.

Answer 2

You could write a function:

public static bool AllEqual<T>(T expectedResult, params T[] calculations)
    where T : IEquatable<T>
{
    return calculations.All(x => x.Equals(expectedResult));
}

For example:

if (AllEqual(4, 2 + 2, 2 * 2, 1 + 1 + 1 + 1)) {
    // true
}

if (AllEqual(4, 2 + 2, 2 * 3)) {
    // not true
}

This even works for other types, e.g.

if (AllEqual("foo", "f" + "o" + "o", "fooo".Substring(0, 3))) {
    // true
}

Answer 3

If you wanted to reduce repition, a Linq query works quite well:

IEnumerable<int> fourExpressions = new List<int>{ 2 + 2, 2 * 2, ... };
bool allEqualToFour = fourExpressions.All(x => x == 4);
if (allEqualToFour) { ... }

or as one line

if (new int[]{ 2 + 2, 2 * 2 }.All(x => x == 4)) { ... }

or (ab)using extension methods for maximum briefness. (Generally, polluting all objects with a helper method like this is not the best idea, so this method could well be left as a static method.)

public static class QuestionableExtensions
{
    public static bool EqualsAllOf<T>(this T value, params T[] collection) where T : IEquatable<T>
    {
        return collection.All(t => value.Equals(t));
    }
}

public class MyClass 
{
    public void MyMethod()
    {
        if (4.EqualsAllOf(2 * 2, 2 + 2)) { ... }
    }
}

The following page has a nice collection of links explaining Linq queries.

Answer 4

You can use this extension method

public static bool SameAs<T>(this T val, params T[] values) where T : struct
{
    return values.All(x => x.Equals(val));
}

if (4.SameAs(2*2,2+2)) { ... }

Answer 5

In reference to @walpen's answer pointing out All is a Linq extension (defined in System.Linq.Enumerable).

I wanted to provide a .NET 2.0 implementation of All, as an extension.

First, we'll define an Attribute called ExtensionAttribute. (SO reference: Using extension methods in .NET 2.0?)

namespace System.Runtime.CompilerServices
{
    [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class
         | AttributeTargets.Method)]
    public sealed class ExtensionAttribute : Attribute { }
}

Then, ( by way of magic) we can use the this reference for extensions. So, we'll create a static class for the usage of the ExtensionAttribute: I choose to do so by defining a static class named Enumerable in System.Collections.Generic namespace.

namespace System.Collections.Generic
{
    public static class Enumerable
    {
        //[System.Runtime.CompilerServices.Extension()]
        public static bool All<T>(this IEnumerable<T> list, T expectedAnswer)
            where T : IEquatable<T>, IComparable<T>
        {
            bool result = true;    
            IEnumerator<T> enumerator = list.GetEnumerator();

            while (enumerator.MoveNext())
            {
                result = result && (Object.Equals(enumerator.Current, expectedAnswer));

                if (!result)
                    return result;
            }
            return result;
        }

        public delegate bool MyFunc<T>(T next);


        public static bool All<T>(this IEnumerable<T> list, MyFunc<T> fn)
            where T : IEquatable<T>, IComparable<T>
        {
            bool result = true;    
            IEnumerator<T> enumerator = list.GetEnumerator();

            while (enumerator.MoveNext())
            {
                result = result && fn.Invoke(enumerator.Current);

                if (!result)
                    return result;
            }
            return result;
        }
    }
}

Then, it's a simple matter of using it.

IEnumerable<int> ints = new int[] { 2 + 2, 2 * 2, 1 * 3 + 1 };
Console.Write("Result := {0}", ints.All(4)); // outputs "Result := true"
Console.Write("Result := {0}", ints.All(t => t.Equals(4))); // outputs "Result := true"

Answer 6

Just tossing a random idea out there

if (new Int32[] { 2 * 2, 2 + 2, ... }.All(t => t == 4))
{
    MessageBox.Show("Yup");
}
else
{
    MessageBox.Show("Nope");
}

Sorry, sorry I misread I removed my previous code. This perform the OP's logic.

All is the only way I can find to do this.