小开

方法如下:

using System.Linq;


if(stringArray.Any(stringToCheck.Contains))


/* or a bit longer: (stringArray.Any(s => stringToCheck.Contains(s))) */

这个函数检查stringToCheck是否包含来自stringArray的子字符串。如果你想确保它包含所有子字符串，将Any更改为All:

if(stringArray.All(stringToCheck.Contains))

小开

最佳答案

你可以这样做:

string stringToCheck = "text1";
string[] stringArray = { "text1", "testtest", "test1test2", "test2text1" };
foreach (string x in stringArray)
{
if (stringToCheck.Contains(x))
{
// Process...
}
}

也许你正在寻找一个更好的解决方案……参考Anton Gogolev的回答，它使用LINQ。

小开

也许是这样的:

string stringToCheck = "text1text2text3";
string[] stringArray = new string[] { "text1" };
if (Array.Exists<string>(stringArray, (Predicate<string>)delegate(string s) {
return stringToCheck.IndexOf(s, StringComparison.OrdinalIgnoreCase) > -1; })) {
Console.WriteLine("Found!");
}

小开

我使用下面的代码来检查字符串是否包含字符串数组中的任何项:

foreach (string s in stringArray)
{
if (s != "")
{
if (stringToCheck.Contains(s))
{
Text = "matched";
}
}
}

小开

试一试:

String[] val = { "helloword1", "orange", "grape", "pear" };
String sep = "";
string stringToCheck = "word1";


bool match = String.Join(sep,val).Contains(stringToCheck);
bool anothermatch = val.Any(s => s.Contains(stringToCheck));

小开

试试这个。示例:检查字段是否包含数组中的任何单词。检查字段(someField)是否包含数组中的任何单词。

String[] val = { "helloword1", "orange", "grape", "pear" };


Expression<Func<Item, bool>> someFieldFilter = i => true;


someFieldFilter = i => val.Any(s => i.someField.Contains(s));

小开

使用LINQ和方法组将是最快和更紧凑的方法。

var arrayA = new[] {"element1", "element2"};
var arrayB = new[] {"element2", "element3"};


if (arrayB.Any(arrayA.Contains))
return true;

小开

⚠️注:这并没有回答所提出的问题
问题是“我如何检查一个句子是否包含单词列表中的单词?”
这个答案检查一个单词列表是否包含一个特定的单词

< / div >

试试这个:

不需要使用LINQ

if (Array.IndexOf(array, Value) >= 0)
{
//Your stuff goes here
}

小开

你也可以做与Anton Gogolev建议道相同的事情来检查stringArray1中的任何物品是否与stringArray2中的任何物品匹配:

using System.Linq;
if(stringArray1.Any(stringArray2.Contains))

同样地，stringArray1中的所有项目匹配stringArray2中的所有项目:

using System.Linq;
if(stringArray1.All(stringArray2.Contains))

小开

public bool ContainAnyOf(string word, string[] array)
{
for (int i = 0; i < array.Length; i++)
{
if (word.Contains(array[i]))
{
return true;
}
}
return false;
}

小开

我使用了类似于IndexOf 由Maitrey684和Theomax的foreach循环的方法来创建这个。(注:前3个"字符串"行只是如何创建数组并将其转换为适当格式的一个示例)。

如果您想比较两个数组，它们将以分号分隔，但最后一个值后面不会有分号。如果你给数组的字符串形式加上一个分号(即a;b;c变成a;b;c;)，你可以使用"x;"无论它在什么位置:

bool found = false;
string someString = "a-b-c";
string[] arrString = someString.Split('-');
string myStringArray = arrString.ToString() + ";";


foreach (string s in otherArray)
{
if (myStringArray.IndexOf(s + ";") != -1) {
found = true;
break;
}
}


if (found == true) {
// ....
}

小开

⚠️注:这并没有回答所提出的问题
问题是“我如何检查一个句子是否包含单词列表中的单词?”
这个答案检查一个单词列表是否包含一个特定的单词

我在控制台应用程序中使用以下命令检查参数

var sendmail = args.Any( o => o.ToLower() == "/sendmail=true");

小开

string [] lines = {"text1", "text2", "etc"};


bool bFound = lines.Any(x => x == "Your string to be searched");

如果搜索的字符串与数组'lines'中的任何元素匹配，bFound将被设置为true。

小开

试试这个

string stringToCheck = "text1text2text3";
string[] stringArray = new string[] { "text1" };


var t = lines.ToList().Find(c => c.Contains(stringToCheck));

它将返回您正在查找的文本的第一个出现的行。

小开

⚠️注:这并没有回答所提出的问题
问题是“我如何检查一个句子是否包含单词列表中的单词?”
这个答案检查一个单词列表是否包含一个特定的单词

只需使用LINQ方法:

stringArray.Contains(stringToCheck)

小开

⚠️注:这并没有回答所提出的问题
问题是“我如何检查一个句子是否包含单词列表中的单词?”
这个答案检查一个单词列表是否包含一个特定的单词

我将使用LINQ，但它仍然可以通过:

new[] {"text1", "text2", "etc"}.Contains(ItemToFind);

小开

如果stringArray包含大量不同长度的字符串，可以考虑使用单词查找树来存储和搜索字符串数组。

public static class Extensions
{
public static bool ContainsAny(this string stringToCheck, IEnumerable<string> stringArray)
{
Trie trie = new Trie(stringArray);
for (int i = 0; i < stringToCheck.Length; ++i)
{
if (trie.MatchesPrefix(stringToCheck.Substring(i)))
{
return true;
}
}


return false;
}
}

下面是Trie类的实现

public class Trie
{
public Trie(IEnumerable<string> words)
{
Root = new Node { Letter = '\0' };
foreach (string word in words)
{
this.Insert(word);
}
}


public bool MatchesPrefix(string sentence)
{
if (sentence == null)
{
return false;
}


Node current = Root;
foreach (char letter in sentence)
{
if (current.Links.ContainsKey(letter))
{
current = current.Links[letter];
if (current.IsWord)
{
return true;
}
}
else
{
return false;
}
}


return false;
}


private void Insert(string word)
{
if (word == null)
{
throw new ArgumentNullException();
}


Node current = Root;
foreach (char letter in word)
{
if (current.Links.ContainsKey(letter))
{
current = current.Links[letter];
}
else
{
Node newNode = new Node { Letter = letter };
current.Links.Add(letter, newNode);
current = newNode;
}
}


current.IsWord = true;
}


private class Node
{
public char Letter;
public SortedList<char, Node> Links = new SortedList<char, Node>();
public bool IsWord;
}


private Node Root;
}

如果stringArray中的所有字符串都具有相同的长度，那么最好使用HashSet而不是Trie

public static bool ContainsAny(this string stringToCheck, IEnumerable<string> stringArray)
{
int stringLength = stringArray.First().Length;
HashSet<string> stringSet = new HashSet<string>(stringArray);
for (int i = 0; i < stringToCheck.Length - stringLength; ++i)
{
if (stringSet.Contains(stringToCheck.Substring(i, stringLength)))
{
return true;
}
}


return false;
}

小开

一个不需要任何LINQ的简单解决方案:

String.Join(",", array).Contains(Value + ",");

小开

⚠️注:这并没有回答所提出的问题
问题是“我如何检查一个句子是否包含单词列表中的单词?”
这个答案检查一个单词列表是否包含一个特定的单词

string strName = "vernie";
string[] strNamesArray = { "roger", "vernie", "joel" };


if (strNamesArray.Any(x => x == strName))
{
// do some action here if true...
}

小开

int result = Array.BinarySearch(list.ToArray(), typedString, StringComparer.OrdinalIgnoreCase);

小开

⚠️注:这并没有回答所提出的问题
问题是“我如何检查一个句子是否包含单词列表中的单词?”
这个答案检查一个单词列表是否包含一个特定的单词

最简单最简单的方法:

bool bol = Array.Exists(stringarray, E => E == stringtocheck);

小开

演示了三个选项。我认为第三条是最简洁的。

class Program {
static void Main(string[] args) {
string req = "PUT";
if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) {
Console.WriteLine("one.1.A");  // IS TRUE
}
req = "XPUT";
if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) {
Console.WriteLine("one.1.B"); // IS TRUE
}
req = "PUTX";
if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) {
Console.WriteLine("one.1.C");  // IS TRUE
}
req = "UT";
if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) {
Console.WriteLine("one.1.D"); // false
}
req = "PU";
if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) {
Console.WriteLine("one.1.E"); // false
}
req = "POST";
if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) {
Console.WriteLine("two.1.A"); // IS TRUE
}
req = "ASD";
if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) {
Console.WriteLine("three.1.A");  // false
}




Console.WriteLine("-----");
req = "PUT";
if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0)  {
Console.WriteLine("one.2.A"); // IS TRUE
}
req = "XPUT";
if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0)  {
Console.WriteLine("one.2.B"); // false
}
req = "PUTX";
if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0)  {
Console.WriteLine("one.2.C"); // false
}
req = "UT";
if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0)  {
Console.WriteLine("one.2.D"); // false
}
req = "PU";
if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0)  {
Console.WriteLine("one.2.E"); // false
}
req = "POST";
if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0)  {
Console.WriteLine("two.2.A");  // IS TRUE
}
req = "ASD";
if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0)  {
Console.WriteLine("three.2.A");  // false
}


Console.WriteLine("-----");
req = "PUT";
if ((new string[] {"PUT", "POST"}.Contains(req)))  {
Console.WriteLine("one.3.A"); // IS TRUE
}
req = "XPUT";
if ((new string[] {"PUT", "POST"}.Contains(req)))  {
Console.WriteLine("one.3.B");  // false
}
req = "PUTX";
if ((new string[] {"PUT", "POST"}.Contains(req)))  {
Console.WriteLine("one.3.C");  // false
}
req = "UT";
if ((new string[] {"PUT", "POST"}.Contains(req)))  {
Console.WriteLine("one.3.D");  // false
}
req = "PU";
if ((new string[] {"PUT", "POST"}.Contains(req)))  {
Console.WriteLine("one.3.E");  // false
}
req = "POST";
if ((new string[] {"PUT", "POST"}.Contains(req)))  {
Console.WriteLine("two.3.A");  // IS TRUE
}
req = "ASD";
if ((new string[] {"PUT", "POST"}.Contains(req)))  {
Console.WriteLine("three.3.A");  // false
}


Console.ReadKey();
}
}

小开

试试这个。没有任何循环的需要。

string stringToCheck = "text1";
List<string> stringList = new List<string>() { "text1", "someothertext", "etc.." };
if (stringList.Exists(o => stringToCheck.Contains(o)))
{


}

小开

你可以定义自己的string.ContainsAny()和string.ContainsAll()方法。作为奖励，我甚至还添加了一个string.Contains()方法，允许不区分大小写的比较等等。

public static class Extensions
{
public static bool Contains(this string source, string value, StringComparison comp)
{
return source.IndexOf(value, comp) > -1;
}


public static bool ContainsAny(this string source, IEnumerable<string> values, StringComparison comp = StringComparison.CurrentCulture)
{
return values.Any(value => source.Contains(value, comp));
}


public static bool ContainsAll(this string source, IEnumerable<string> values, StringComparison comp = StringComparison.CurrentCulture)
{
return values.All(value => source.Contains(value, comp));
}
}

你可以用下面的代码进行测试:

    public static void TestExtensions()
{
string[] searchTerms = { "FOO", "BAR" };
string[] documents = {
"Hello foo bar",
"Hello foo",
"Hello"
};


foreach (var document in documents)
{
Console.WriteLine("Testing: {0}", document);
Console.WriteLine("ContainsAny: {0}", document.ContainsAny(searchTerms, StringComparison.OrdinalIgnoreCase));
Console.WriteLine("ContainsAll: {0}", document.ContainsAll(searchTerms, StringComparison.OrdinalIgnoreCase));
Console.WriteLine();
}
}

小开

要完成前面的答案，对于IgnoreCase检查，使用:

stringArray.Any(s => stringToCheck.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) > -1)

小开

在我的案例中，上述答案并不奏效。我正在检查数组中的字符串，并将其分配给布尔值。我修改了Anton Gogolev的回答并删除了Any()方法，并将stringToCheck放在Contains()方法中。

bool isContain = stringArray.Contains(stringToCheck);

小开

⚠️注:这并没有回答所提出的问题
问题是“我如何检查一个句子是否包含单词列表中的单词?”
这个答案检查一个单词列表是否包含一个特定的单词

  stringArray.ToList().Contains(stringToCheck)

小开

使用数组类的找到或FindIndex方法:

if(Array.Find(stringArray, stringToCheck.Contains) != null)
{
}

if(Array.FindIndex(stringArray, stringToCheck.Contains) != -1)
{
}

小开

这些解决方案大多数是正确的，但如果你需要检查值不区分大小写:

using System.Linq;
...
string stringToCheck = "text1text2text3";
string[] stringArray = { "text1", "someothertext"};


if(stringArray.Any(a=> String.Equals(a, stringToCheck, StringComparison.InvariantCultureIgnoreCase)) )
{
//contains
}


if (stringArray.Any(w=> w.IndexOf(stringToCheck, StringComparison.InvariantCultureIgnoreCase)>=0))
{
//contains
}

dotNetFiddle example

小开

您也可以尝试这个解决方案。

string[] nonSupportedExt = { ".3gp", ".avi", ".opus", ".wma", ".wav", ".m4a", ".ac3", ".aac", ".aiff" };
        

bool valid = Array.Exists(nonSupportedExt,E => E == ".Aac".ToLower());

小开

LINQ:

arrray。任何(x =比;word.Equals (x));

这是为了查看数组是否包含单词(精确匹配)。使用. contains作为子字符串，或者其他任何你可能需要应用的逻辑。

使用c#检查字符串数组中是否包含字符串

试试这个: