Ich möchte C # verwenden, um zu überprüfen, ob ein Zeichenfolgenwert ein Wort in einem Zeichenfolgenarray enthält. Zum Beispiel,

string stringToCheck = "text1text2text3";

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

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

}

Wie kann ich überprüfen, ob der Zeichenfolgenwert für 'stringToCheck' ein Wort im Array enthält?

Hier ist, wie Sie es tun können:

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

UPDATE: Vielleicht suchen Sie nach einer besseren Lösung. Lesen Sie die Antwort von @Anton Gogolev, in der LINQ verwendet wird.

Hier ist wie:

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

Dies prüft, ob stringToCheckeine der Teilzeichenfolgen von enthalten ist stringArray. Wenn Sie sicherstellen möchten, dass alle Teilzeichenfolgen enthalten sind, wechseln Sie Anyzu All:

if(stringArray.All(stringToCheck.Contains))

Versuche dies:

LINQ muss nicht verwendet werden

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

Verwenden Sie einfach die linq-Methode:

stringArray.Contains(stringToCheck)

Einfachste und einfachste Art und Weise.

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

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

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

So etwas vielleicht:

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

Die Verwendung von Linq und Methodengruppen wäre der schnellste und kompaktere Weg, dies zu tun.

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

Sie können Ihre eigenen string.ContainsAny()und string.ContainsAll()Methoden definieren. Als Bonus habe ich sogar eine string.Contains()Methode eingeführt, die einen Vergleich ohne Berücksichtigung der Groß- und Kleinschreibung usw. ermöglicht.

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

Sie können diese mit folgendem Code testen:

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

Ich verwende Folgendes in einer Konsolenanwendung, um nach Argumenten zu suchen

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

Ich würde Linq verwenden, aber es kann immer noch getan werden durch:

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

Versuchen:

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

Sie können auch das Gleiche tun, wie Anton Gogolev vorschlägt, um zu überprüfen, ob ein Artikel in stringArray1mit einem Artikel in übereinstimmt stringArray2:

if(stringArray1.Any(stringArray2.Contains))

Ebenso stimmen alle Elemente in stringArray1 mit allen Elementen in stringArray2 überein:

if(stringArray1.All(stringArray2.Contains))

stringArray.ToList().Contains(stringToCheck)

Versuchen Sie dies, hier das Beispiel: Um zu überprüfen, ob das Feld eines der Wörter im Array enthält. Um zu überprüfen, ob das Feld (someField) eines der Wörter im Array enthält.

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

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

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

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

Ich habe eine ähnliche Methode wie IndexOf von Maitrey684 und die foreach-Schleife von Theomax verwendet, um dies zu erstellen. (Hinweis: Die ersten 3 "String" -Zeilen sind nur ein Beispiel dafür, wie Sie ein Array erstellen und in das richtige Format bringen können.)

Wenn Sie zwei Arrays vergleichen möchten, werden diese durch Semikolons getrennt, aber der letzte Wert hat keinen nach. Wenn Sie ein Semikolon an die Zeichenfolgenform des Arrays anhängen (dh a; b; c wird zu a; b; c;), können Sie mit "x;" egal in welcher Position es ist:

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) { 
    // ....
}

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

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

bFound wird auf true gesetzt, wenn die gesuchte Zeichenfolge mit einem Element des Arrays 'lines' übereinstimmt.

Versuche dies

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

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

Sie erhalten die Zeile mit dem ersten Vorkommen des gesuchten Textes zurück.

Wenn stringArrayeine große Anzahl von Zeichenfolgen unterschiedlicher Länge enthalten ist, sollten Sie einen Trie zum Speichern und Durchsuchen des Zeichenfolgenarrays verwenden.

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

Hier ist die Implementierung der TrieKlasse

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

Wenn alle Zeichenfolgen stringArraydieselbe Länge haben, ist es besser, wenn Sie nur a HashSetanstelle von a verwendenTrie

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

Einfache Lösung, keine Linq erforderlich

String.Join (",", Array) .Contains (Wert + ",");

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

Versuchen Sie dies, keine Notwendigkeit für eine Schleife ..

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

}

Um die obigen Antworten zu vervollständigen , verwenden Sie für die IgnoreCase- Prüfung Folgendes :

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

In meinem Fall haben die obigen Antworten nicht funktioniert. Ich habe in einem Array nach einer Zeichenfolge gesucht und sie einem booleschen Wert zugewiesen. Ich veränderte Antwort des @Anton Gogolev und entfernt , um das Any()Verfahren und setzte die im stringToCheckInnern des Contains()Verfahrens.

bool = stringArray.Contains(stringToCheck);

Verwenden der Find- oder FindIndex- Methoden der Array- Klasse:

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

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

Ich habe den folgenden Code verwendet, um zu überprüfen, ob die Zeichenfolge eines der Elemente im Zeichenfolgenarray enthält:

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

Drei Optionen demonstriert. Ich bevorzuge es, den dritten als den prägnantesten zu finden.

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