Determine if values are different

For readability and understanding, I would swap the logic. When you check if values are different it's not clear - all values should be different (consider integer values 1, 2, 3), or values could be equal, but there is at least one different value (1, 2, 1)? When you check if all values are equal it's always clear.

And I would extract this logic to the nicely named method (you can even make it generic if you want):

public static bool AllEqual(params bool[] values)
{
    if (values.Length == 0)
       return true;

    var first = values[0];
    for (int i = 1; i < values.Length; i++)
        if (values[i] != first)
            return false;

    return true;
}

And usage

var notAllEqual = !AllEqual(value1, value2, value3, value4);

With declarative approach your code describes what you are doing instead of telling how and leaving the reader on its own to understand what.

Update: If you always deal with four boolean values, the simplest way to check if they are not all equal is

(value1 ^ value2) || (value2 ^ value3) || (value3 ^ value4)

But in terms of readability, any imperative approach is worse than declarative

You can combine the bits and check

int value = (value1 ? 8 : 0) |
            (value2 ? 4 : 0) |
            (value3 ? 2 : 0) |
            (value4 ? 1 : 0);
return value != 0 && value != 15;

Maybe Linq is declarative enough?

var values = new[] { false, false, true, false };
bool notAllEqual = values.Any(x => x != values.First());

Alternatively:

var values = new[] { false, false, true, false };
bool allEqual = values.All(x => x == values.First());
if (!allEqual)
{
     // They are different
}

You said you want to check if your elements not

all are true || all are false

Given a list var values = new List<bool> { value1, value2, value3, value4 }; of those elements, the closest representation in code would be:

var areDifferent = !(values.All(v => v == true) || values.All(v => v == false));

In terms of readability though, I would prefer:

var areEqual = values.All(v => v == true) || values.All(v => v == false);

and later check:

 if (!areEqual)
 {
     // Do something
 }

But that's just personal preference.

This seems to me a code smell, you might need to refactor the code instead of searching of a better way to display the booleans.

Without providing the actual code, you'll always get assumptions and not answers.

Anyhow, regarding to your specific question, you can create a public static class and use it as results tester to validate all kind of results through out your code. This way, you can reuse it, and also would be more readable.

for instance :

public static class Validate
{
    public static bool AreEqual(params bool[] values) => AreTrue(values) || AreFalse(values);
    
    public static bool AreTrue(params bool[] values) => values.All(x => x == true);
    
    public static bool AreFalse(params bool[] values) => values.All(x => x == false);
}

then use it like this :

bool value1 = false;
bool value2 = false;
bool value3 = true;
bool value4 = false;

if(Validate.AreEqual(value1 , value2 , value3 , value4))
{
    // do something
}

Although personally, I prefer your first approach, the following works as well.

bool value1 = false;
bool value2 = false;
bool value3 = true;
bool value4 = false;

var values = new[] { value1, value2, value3, value4 };

bool areDifferent = values.Any(v => v) && values.Any(v => !v);

@phuclv's approach made generic:

static bool AreDifferent(params bool[] values)
{
    var tmp = values.Select((value, index) => value ? 1 << index : 0).Aggregate((i, j) => i | j);
    return tmp != 0 && tmp != (1 << values.Length) - 1;
}

For understanding purpose, we can create a method and use if blocks.

public bool areDifferent(bool value1, bool value2, bool value3, bool value4)
{
    if(value1 == value2)
        if(value2 == value3)
            if(value3 == value4)
                return false;
                    
    return true;
}