Take previous element from array if condition on current element matches

Question

Any ideas to simplify this beauty; I would prefer a LinQ expression if possible:

private object[] array;
public abstract bool Condition(object o);
//...
private object FindStuff()
{
    for (int i = 0; i < array.Length; i++)
    {
        if (Condition(array[i]))
        {
            return i == 0 ? null : array[i-1];
        }
    }
    throw new ItemNotFoundException();
}
//...

Answer 1

This code would benefit from a previous variable...... and it would also benefit from being real code, not this hypothetical example..... This code is also really short, so it's hard to simplify more.

Still, using a foreach is better than the indexed iterator, and the logic is more obvious with named variables, rather than indexes... so:

private object[] array;
public abstract bool Condition(object o);
//...
private object FindStuff()
{
    object previous = null;
    foreach (object current in array)
    {
        if (Condition(current))
        {
            return previous;
        }
        previous = current;
    }
    throw new ItemNotFoundException();
}

Answer 2

List<T> has FindIndex(Predicate<T>) which returns index or -1 when item was not found.

private static object FindStuff(List<object> list)
{
    int index = list.FindIndex(Condition);

    if (index < 0) throw new ItemNotFoundException();

    if (index == 0) return null;

    return list[index - 1];
}

private static bool Condition(object o)
{
    return true;
}

I don't like returning null, but whateva :)

Answer 3

The question seems to be missing an important constraint in case there are repeating elements in the input collection that satisfy the condition given. Therefore, there is an assumption around the solutions provided that we are interested in the first encounter only.

How about a more general approach to return an IEnumerable collection so that the caller can decide what to take out of that such as the first, the last or the nth, etc.

    private static IEnumerable<object> Find(object[] array)
    {
        if (array == null) throw new ArgumentNullException(nameof(array));

        object previous = null;
        foreach (var current in array)
        {
            if (Predicate(current)) yield return previous;

            previous = current;
        }
    }

    private static bool Predicate(object o)
    {
        return o != null && (int)o == 2;
    }

There is also a null check for the input to fail fast. Predicate logic is irrelevant here.

Following is the test cases for the Find method:

    [Test]
    public void TestFind()
    {
        var items = Find(new object[] { 1, 2, 5, 2, 10, 2, 100, 2 });
        Assert.AreEqual(1, items.First());

        items = Find(new object[] { 0, 1, 1, 1, 1, 1 });
        Assert.IsEmpty(items);

        Assert.Throws<ArgumentNullException>(() => Find(null).ToList());
    }