【问题标题】：Using C# to check if string contains a string in string array使用 C# 检查字符串是否包含字符串数组中的字符串
【发布时间】：2011-02-24 03:27:15
【问题描述】：

我想使用 C# 检查字符串值是否包含字符串数组中的单词。例如，

string stringToCheck = "text1text2text3";

string[] stringArray = { "text1", "someothertext", etc... };

if(stringToCheck.contains stringArray) //one of the items?
{

}

如何检查 'stringToCheck' 的字符串值是否包含数组中的单词？

【问题讨论】：

这篇博客对许多测试字符串是否包含字符串的技术进行了基准测试：blogs.davelozinski.com/curiousconsultant/…

标签： c# arrays string search

【解决方案1】：

方法如下：

using System.Linq;

if(stringArray.Any(stringToCheck.Contains))

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

这将检查 stringToCheck 是否包含来自 stringArray 的任何子字符串。如果要确保它包含所有子字符串，请将@987654325@ 更改为All：

if(stringArray.All(stringToCheck.Contains))

【讨论】：

自我说明：linq 很棒，linq 很棒，linq 很棒！必须开始使用 linq。
@Spooks Linq To Objects（用于答案的字符串检查）可以通过 .NET 2.0 上的 LinqBridge 使用 albahari.com/nutshell/linqbridge.aspx
您将如何使用大小写不变性来做到这一点？
@Offler 那是stringArray.Any(s => s.IndexOf(stringToCheck, StringComparison.CurrentCultureIgnoreCase) > -1)
如何获取数组中匹配的项？

【解决方案2】：

你可以这样做：

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

更新：您可能正在寻找更好的解决方案。请参阅下面使用 LINQ 的@Anton Gogolev 的回答。

【讨论】：

谢谢，我将您的代码修改为：if (stringToCheck.Contains(s)) 并且成功了。
我做了 if (stringArray.Contains(stringToCheck)) 并且效果很好，谢谢。
不要使用这个答案，而是使用 LINQ
对在字符串数组上看不到 Contains 方法的人的小提示：检查您是否有“使用 System.Linq;”代码文件中的命名空间:)
Linq 在旧版软件中并不总是可用。

【解决方案3】：

试试这个：

无需使用 LINQ

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

【讨论】：

不错！ Linq 可能比 Array.IndexOf 有什么好处？？
这根本不能解决问题。 IndexOf 告诉你一个数组是否包含一个字符串的精确匹配，最初的问题是一个字符串是否包含一个字符串数组，Linq 可以轻松处理。
我知道这个评论迟了，但对于那些不知道的人来说，字符串是一个字符数组，所以字符串类型确实包含一个 IndexOf 方法......所以@NetMage 这是可能的解决方案。
@Blacky Wolf，你读过这个问题吗？ Array.IndexOf 告诉您数组是否包含一个值，OP 想知道一个值是否包含数组的任何成员，这与这个答案完全相反。您可以将 String.IndexOf 与 Linq 一起使用：stringArray.Any(w => stringToCheck.IndexOf(w) >= 0) 但使用 String.Contains 的 Linq 答案更有意义，因为这正是所要求的。

【解决方案4】：

只需使用 linq 方法：

stringArray.Contains(stringToCheck)

【讨论】：

注意，Contains是一个扩展方法，你需要做using System.Linq;
这个答案是从问题倒过来的。
这个答案怎么被投票这么多次？提出问题 5 年后，解决方案基本上与问题所问的相反。
也许只是把变量名颠倒一下就可以了？

【解决方案5】：

最简单的示例方法。

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

【讨论】：

更好的是 stringarray.Exists(entity => entity == stringtocheck)
我认为你不能直接从字符串数组调用exists方法。Exists方法可以直接用于list。所以应该使用静态方法array.exist作为字符串数组。在这里检查=> msdn.microsoft.com/en-us/library/yw84x8be(v=vs.110).aspx

【解决方案6】：

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

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

【讨论】：

我认为这不是问题所要求的。

【解决方案7】：

可能是这样的：

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

【讨论】：

这是一个更好的解决方案，因为它是对列表中单词的子字符串检查，而不是完全匹配检查。
不错的答案，但是与现代 C# 相比，即使没有 Linq，这也很难阅读；此外，String.Contains 可能比 String.IndexOf 更好，除非您想忽略大小写，因为 Microsoft 忘记了两个参数 String.Contains 您必须自己编写。考虑：Array.Exists(stringArray, s => stringToCheck.IndexOf(s, StringComparison.OrdinalIgnoreCase) > -1)

【解决方案8】：

stringArray.ToList().Contains(stringToCheck)

【讨论】：

【解决方案9】：

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

var arrayA = new[] {"element1", "element2"};
var arrayB = new[] {"element2", "element3"};
if (arrayB.Any(arrayA.Contains)) return true;

【讨论】：

【解决方案10】：

您可以定义自己的 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();
        }
    }

【讨论】：

【解决方案11】：

我在控制台应用程序中使用以下内容来检查参数

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

【讨论】：

【解决方案12】：

我会使用 Linq，但仍然可以通过以下方式完成：

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

【讨论】：

【解决方案13】：

使用Array 类的Find 或FindIndex 方法：

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

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

【讨论】：

【解决方案14】：

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

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

【讨论】：

【解决方案15】：

你也可以试试这个解决方案。

string[] nonSupportedExt = { ".3gp", ".avi", ".opus", ".wma", ".wav", ".m4a", ".ac3", ".aac", ".aiff" };
        
bool valid = Array.Exists(nonSupportedExt,E => E == ".Aac".ToLower());

【讨论】：

【解决方案16】：

试试：

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

【讨论】：

【解决方案17】：

您也可以按照 Anton Gogolev 的建议检查 stringArray1 中的 any item 是否与 stringArray2 中的 any item 匹配：

if(stringArray1.Any(stringArray2.Contains))

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

if(stringArray1.All(stringArray2.Contains))

【讨论】：

【解决方案18】：

如果stringArray 包含大量不同长度的字符串，请考虑使用Trie 来存储和搜索字符串数组。

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

【讨论】：

【解决方案19】：

要完成上述答案，对于 IgnoreCase 检查使用：

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

【讨论】：

有什么方法可以得到匹配的索引吗？谢谢。

【解决方案20】：

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

bool isContain = stringArray.Contains(stringToCheck);

【讨论】：

【解决方案21】：

试试这个，这里是例子：检查字段是否包含数组中的任何单词。检查字段（someField）是否包含数组中的任何单词。

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

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

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

【讨论】：

【解决方案22】：

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

【讨论】：

【解决方案23】：

我使用了与 Maitrey684 的 IndexOf 和 Theomax 的 foreach 循环类似的方法来创建它。（注意：前 3 行“字符串”只是说明如何创建数组并将其转换为正确格式的示例）。

如果要比较 2 个数组，它们将以分号分隔，但最后一个值后面不会有一个。如果将分号附加到数组的字符串形式（即 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) { 
    // ....
}

【讨论】：

【解决方案24】：

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

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

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

【讨论】：

【解决方案25】：

试试这个

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

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

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

【讨论】：

【解决方案26】：

简单的解决方案，不需要 linq 任何

String.Join(",", 数组).Contains(Value+",");

【讨论】：

如果数组中的某个值包含您的分隔符怎么办？

【解决方案27】：

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

【讨论】：

【解决方案28】：

试试这个，不需要循环..

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

}

【讨论】：

【解决方案29】：

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

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

【讨论】：

这设置Text = "matched" 的次数与stringToCheck 包含stringArray 的子串一样多。您可能想在分配后添加break 或return。

【解决方案30】：

演示了三个选项。我更喜欢找到第三个，因为它最简洁。

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

【讨论】：

您的后两个选项甚至不会在第一个选项中做同样的事情。