Bagaimana cara memeriksa apakah suatu String berisi salah satu dari beberapa string

Saya ingin memeriksa apakah String s, berisi "a" atau "b" atau "c", di C #. Saya mencari solusi yang lebih bagus daripada menggunakan

if (s.contains("a")||s.contains("b")||s.contains("c"))

Jika Anda mencari karakter tunggal, Anda dapat menggunakan String.IndexOfAny().

Jika Anda menginginkan string arbitrer, maka saya tidak mengetahui metode .NET untuk mencapai itu "secara langsung", meskipun ekspresi reguler akan berfungsi.

Nah, selalu ada ini:

public static bool ContainsAny(this string haystack, params string[] needles)
{
    foreach (string needle in needles)
    {
        if (haystack.Contains(needle))
            return true;
    }

    return false;
}

Pemakaian:

bool anyLuck = s.ContainsAny("a", "b", "c");

Namun, tidak ada yang akan menandingi kinerja rantai ||perbandingan Anda.

Berikut solusi LINQ yang hampir sama tetapi lebih skalabel:

new[] { "a", "b", "c" }.Any(c => s.Contains(c))

var values = new [] {"abc", "def", "ghj"};
var str = "abcedasdkljre";
values.Any(str.Contains);

Anda dapat mencoba dengan ekspresi reguler

string s;
Regex r = new Regex ("a|b|c");
bool containsAny = r.IsMatch (s);

Jika Anda membutuhkan ContainsAny dengan spesifik StringComparison(misalnya untuk mengabaikan kasus) maka Anda dapat menggunakan metode Ekstensi String ini.

public static class StringExtensions
{
    public static bool ContainsAny(this string input, IEnumerable<string> containsKeywords, StringComparison comparisonType)
    {
        return containsKeywords.Any(keyword => input.IndexOf(keyword, comparisonType) >= 0);
    }
}

Penggunaan dengan StringComparison.CurrentCultureIgnoreCase:

var input = "My STRING contains Many Substrings";
var substrings = new[] {"string", "many substrings", "not containing this string" };
input.ContainsAny(substrings, StringComparison.CurrentCultureIgnoreCase);
// The statement above returns true.

”xyz”.ContainsAny(substrings, StringComparison.CurrentCultureIgnoreCase);
// This statement returns false.

Ini adalah "solusi yang lebih baik" dan cukup sederhana

if(new string[] { "A", "B", ... }.Any(s=>myString.Contains(s)))

Karena string adalah kumpulan karakter, Anda dapat menggunakan metode ekstensi LINQ padanya:

if (s.Any(c => c == 'a' || c == 'b' || c == 'c')) ...

Ini akan memindai string sekali dan berhenti pada kejadian pertama, alih-alih memindai string satu kali untuk setiap karakter hingga ditemukan kecocokan.

Ini juga dapat digunakan untuk ekspresi apa pun yang Anda suka, misalnya memeriksa rentang karakter:

if (s.Any(c => c >= 'a' && c <= 'c')) ...

public static bool ContainsAny(this string haystack, IEnumerable<string> needles)
{
    return needles.Any(haystack.Contains);
}

List<string> includedWords = new List<string>() { "a", "b", "c" };
bool string_contains_words = includedWords.Exists(o => s.Contains(o));

// Nice method's name, @Dan Tao

public static bool ContainsAny(this string value, params string[] params)
{
    return params.Any(p => value.Compare(p) > 0);
    // or
    return params.Any(p => value.Contains(p));
}

Anyuntuk setiap, Alluntuk setiap

    static void Main(string[] args)
    {
        string illegalCharacters = "!@#$%^&*()\\/{}|<>,.~`?"; //We'll call these the bad guys
        string goodUserName = "John Wesson";                   //This is a good guy. We know it. We can see it!
                                                               //But what if we want the program to make sure?
        string badUserName = "*_Wesson*_John!?";                //We can see this has one of the bad guys. Underscores not restricted.

        Console.WriteLine("goodUserName " + goodUserName +
            (!HasWantedCharacters(goodUserName, illegalCharacters) ?
            " contains no illegal characters and is valid" :      //This line is the expected result
            " contains one or more illegal characters and is invalid"));
        string captured = "";
        Console.WriteLine("badUserName " + badUserName +
            (!HasWantedCharacters(badUserName, illegalCharacters, out captured) ?
            " contains no illegal characters and is valid" :
            //We can expect this line to print and show us the bad ones
            " is invalid and contains the following illegal characters: " + captured));  

    }

    //Takes a string to check for the presence of one or more of the wanted characters within a string
    //As soon as one of the wanted characters is encountered, return true
    //This is useful if a character is required, but NOT if a specific frequency is needed
    //ie. you wouldn't use this to validate an email address
    //but could use it to make sure a username is only alphanumeric
    static bool HasWantedCharacters(string source, string wantedCharacters)
    {
        foreach(char s in source) //One by one, loop through the characters in source
        {
            foreach(char c in wantedCharacters) //One by one, loop through the wanted characters
            {
                if (c == s)  //Is the current illegalChar here in the string?
                    return true;
            }
        }
        return false;
    }

    //Overloaded version of HasWantedCharacters
    //Checks to see if any one of the wantedCharacters is contained within the source string
    //string source ~ String to test
    //string wantedCharacters ~ string of characters to check for
    static bool HasWantedCharacters(string source, string wantedCharacters, out string capturedCharacters)
    {
        capturedCharacters = ""; //Haven't found any wanted characters yet

        foreach(char s in source)
        {
            foreach(char c in wantedCharacters) //Is the current illegalChar here in the string?
            {
                if(c == s)
                {
                    if(!capturedCharacters.Contains(c.ToString()))
                        capturedCharacters += c.ToString();  //Send these characters to whoever's asking
                }
            }
        }

        if (capturedCharacters.Length > 0)  
            return true;
        else
            return false;
    }

Anda dapat menggunakan Ekspresi Reguler

if(System.Text.RegularExpressions.IsMatch("a|b|c"))

Jika Anda mencari string arbitrer, dan bukan hanya karakter, Anda dapat menggunakan overload IndexOfAny yang mengambil argumen string dari project baru NLib :

if (s.IndexOfAny("aaa", "bbb", "ccc", StringComparison.Ordinal) >= 0)