int a, b, c, d, e;
a = b = c = d = e = 1;
if ((a==b) && (b==c) && (c==d) && (d==e))
{
Console.WriteLine("that syntax is horrible");
}
Есть ли более элегантный способ проверить множественное равенство, как указано выше?цепные болты в C#
Возможно, AreEqual(params obj[]) или что-то еще? У меня был Google, но ничего не нашел.
Возможная реализация AreEqual(params object[] objects):
(Следуя совету Джона Скита, вот общая версия)
bool AreEqual<T>(params T[] objects)
{
if (objects.Length <= 1) return true;
return objects.Skip(1).All(x => x.Equals(objects[0]));
}
Skip(1) не является строго необходимо либо.
Да, linq - это путь :-) –
спасибо Aviad, я знаю, что это тривиально реализовать, просто подумал, что, возможно, уже существует подходящий метод. – fearofawhackplanet
Я бы сделал это универсальным методом вместо того, чтобы принимать 'object []' хотя ... –
Нет, это самый разумный способ (я имею в виду самое , которое можно читать, что является самым важным).
Реальный вопрос: зачем вам это нужно? Похоже, плохой дизайн в первую очередь ...
Как на самом деле это может быть плохой дизайн, который нужно проверить, если куча вещей одинакова? вы честно говорите, что нет никакой возможной причины когда-либо делать это? это именно такой комментарий «общего мнения», который я считаю настолько расстраивающим с этого сайта. Вы хотите, чтобы я опубликовал все 50K строк кода, чтобы вы могли понять, почему я хочу это сделать? – fearofawhackplanet
Довольно я говорю, что да; нет особых причин, чтобы расстраиваться в моем ответе. Я оставлю вас к этому. –
Я не думаю, что он имел в виду, что вам никогда не придется проверять, равноценны ли какие-либо вещи, просто, что может быть более сжатый способ делать вещи (в зависимости от остальной части вашего кода). –
Вот общий вариант, который позволит избежать бокс (и более типобезопасный во время компиляции):
public static bool AllEqual<T>(T firstItem, params T[] items)
{
// Omitted error checking
EqualityComparer<T> comparer = EqualityComparer<T>.Default;
foreach (T item in items)
{
if (!comparer.Equals(firstItem, item))
{
return false;
}
}
return true;
}
Обратите внимание, что это не будет столь же удобно, если вы действительно хотите передать кучу значений вы уже попали в массив, но избегаете проблем с пустыми массивами - и это означает, что у вас нет избыточных сравнений.
Это не то же самое, что у orignal; (если вы переопределите «Equals», это будет использовать эту реализацию). –
@silky: Какую версию вы предлагаете не использовать переопределенные равные? Единственное различие заключалось бы в том, что если бы кто-то реализовал Equals (объект) по-другому для их реализации IEqualityComparer - в этом случае у них были большие проблемы с IMO. –
Jon: * original * (т. Е. Код OPs). И нет, будет иметь значение, если он действительно захочет сделать сравнительный анализ. Это очень маловероятно, но это показывает вредоносность наивного преобразования в какую-то сложную схему, которая в конечном счете, ИМХО, менее читаема и даже не требуется. –
Если вы сравниваете простые типы и у вас есть только несколько вариантов использования, то вы можете создать несколько вспомогательных методов, таких как:
bool AllEqual(int first, params int[] numbers)
{
return numbers.All(x => x == first);
}
Это весело
int a, b, c, d, e;
a = b = c = d = e = 1;
if ((a & b & c & d) == e)
{
Console.WriteLine("that syntax is horrible");
}
и это может быть лучше
int a, b, c, d, e;
a = b = c = d = e = 1;
if (new[] {a, b, c, d, e}.All(i => i == a))
{
Console.WriteLine("Funky chicken");
}
Этот код даст неправильные результаты. Обратите внимание, что '&' выполняет поразрядное и. Результат оказывается правильным * если * все значения равны, но он * может * быть неверным для разных значений (т. Е. Результат будет по-прежнему «истинным», хотя значения не все равны). –
хех, так это :) – mcintyre321
Элегантный: (a & b & c & d & e) == (a | b | c | d | e), но не легко понять. – Skizz