如何检查字符串是否包含某些字符串

总是这样:

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


return false;
}

用法:

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

然而，没有什么比得上 ||比较链的性能。

您可以尝试使用正则表达式

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

你可以使用 正则表达式

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

如果要查找单个字符，可以使用 String.IndexOfAny()。

如果您想要任意字符串，那么我不知道。NET 方法来“直接”实现这一点，尽管正则表达式可以工作。

这里有一个 LINQ 解决方案，它实际上是相同的，但是可扩展性更强:

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

因为字符串是字符的集合，所以可以对它们使用 LINQ 扩展方法:

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

这将扫描字符串一次，并在第一次出现时停止，而不是为每个字符扫描字符串一次，直到找到匹配。

这也可以用于任何你喜欢的表达式，例如检查一个字符范围:

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

// 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));
}

Any代表任何，All代表任何

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

这是一个“更好的解决方案”，而且相当简单

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

如果您需要 ContainsAnywith 一个特定的 StringComparison(例如忽略大小写) ，那么您可以使用这个字符串扩展方法。

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);
}
}

与 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.

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));

    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;
}

您可以为扩展方法创建一个类，并添加以下方法:

    public static bool Contains<T>(this string s, List<T> list)
{
foreach (char c in s)
{
foreach (T value in list)
{
if (c == Convert.ToChar(value))
return true;
}
}
return false;
}

如果这是针对有要求的密码检查器，请尝试以下操作:

public static bool PasswordChecker(string input)
{
// determins if a password is save enough
if (input.Length < 8)
return false;


if (!new string[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R",
"S", "T", "U", "V", "W", "X", "Y", "Z", "Ä", "Ü", "Ö"}.Any(s => input.Contains(s)))
return false;


if (!new string[] { "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"}.Any(s => input.Contains(s)))
return false;


if (!new string[] { "!", "'", "§", "$", "%", "&", "/", "(", ")", "=", "?", "*", "#", "+", "-", "_", ".",
",", ";", ":", "`", "´", "^", "°",   }.Any(s => input.Contains(s)))
return false;


return true;
}

这将设置密码的最小长度为8，使其使用至少一个大写字符、至少一个数字和至少一个特殊字符