Determining whether a string ends with one of a few given options

Question

I wrote the following function to determine whether a string ends with one of a few given options.

I'm sure it can be written more elegantly, probably avoiding the loop.

bool EndsWithOneOf(string value, IEnumerable<string> suffixes)
{ 
    foreach(var suffix in suffixes)
    {
        if value.EndsWith(suffix)
            return true;
    }
    return false;
}

Answer 1

You can LINQify it to improve readability:

bool endsWithOneOf = suffixes.Any(x => value.EndsWith(x));

Note that this doesn't "avoid the loop", since Any() will iterate through the suffixes (stopping when it hits a match.) But that's ok, since how else could you do it? You have an enumeration of suffixes, so to do anything with them, you must enumerate them.

Answer 2

bool EndsWithOneOf(string value, IEnumerable<string> suffixes)
{
    return suffixes.Any(suffix => value.EndsWith(suffix));
}

Edit: too late :D

Update

My previous answer was given multiple times, but this works too. Using a method group:

bool EndsWithOneOf(string value, IEnumerable<string> suffixes)
{
    return suffixes.Any(value.EndsWith);
}

Answer 3

static bool EndsWithOneOf(this string value, IEnumerable<string> suffixes)
{
    return suffixes.Any(suffix => value.EndsWith(suffix));
}

Two advantages here:

1. use of extension method makes calling this method more straight forward (i.e. mystring.EndsWithOneOf(mySuffixes);)
2. Use of linq allows for better readability (see declarative vs imperative programming)

Answer 4

Regardless of how you do it, at some point in the execution of a method like that, there will be a enumeration.

What you can do, is make the method more terse by using a LINQ method:

return suffixes.Any(s => value.EndsWith(s));

But is that any more readable than:

foreach (string suffix in suffixes) {
    if (value.EndsWith(suffix)) return true;
}
return false;

For actual method improvements, you should consider argument validation. What happens if value is null? Your current code will return in a NullReferenceException.

Behaviourly would it be correct to throw an ArgumentNullException in this case? Or is the possible null value an automatic resultant value of false?

You should also consider how your are comparing strings? Should you provide an overload that allows the caller to pass in an appropriate CultureInfo object? Or perhaps specify the StringComparison?

Answer 5

I dont think this is relevant given your question example, and therefore this answer may be pointless, but an alternative is that you can invert the comparison test to eliminate the enumeration.

For example, if you were looking for file type extensions, then instead of comparing the filename against a collection of extensions (like has been solved already), you can build a single string containing all the extensions (plus maybe an extra token), and then search for the input filename type in that string.

E.g. ".png.jpg.bmp.mov.mp3.".contains(myFileExtension + ".");

I've used this approach a few times to unravel a loop.