Verwenden Sie C #, um zu überprüfen, ob Zeichenfolge eine Zeichenfolge im Zeichenfolgenarray enthält

Hier ist wie:

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

Dies prüft, ob stringToCheck einen der Teilstrings von stringArray enthält. Wenn Sie sicherstellen möchten, dass alle Teilzeichenfolgen enthalten sind, ändern Sie Any in All:

if(stringArray.All(stringToCheck.Contains))

Versuche dies:

Keine Notwendigkeit, LINQ zu verwenden

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

Verwenden Sie einfach die linq-Methode:

stringArray.Contains(stringToCheck)

(Leider kann kein Kommentar zu vorhandenen Antworten hinzugefügt werden, da mein Ruf <50 ist).

Einfachste und probeweise.

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

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 der Methodengruppe 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;

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

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

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 dasselbe tun, als Anton Gogolev vorschlägt, zu prüfen, ob jedes Element in stringArray1 mit jedes Element in stringArray2 übereinstimmt:

if(stringArray1.Any(stringArray2.Contains))

Und ebenfalls alle Elemente in stringArray1 stimmen mit alle Elemente in StringArray2 überein:

if(stringArray1.All(stringArray2.Contains))

Sie können Ihre eigenen string.ContainsAny()- und string.ContainsAll()-Methoden definieren. Als Bonus habe ich sogar eine string.Contains()-Methode geworfen, die einen Vergleich zwischen Groß- und Kleinschreibung usw. erlaubt.

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 würde Linq verwenden, aber es geht noch durch:

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

In einer Konsolenanwendung verwende ich Folgendes, um nach Argumenten zu suchen

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

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

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

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 zu dem IndexOf von Maitrey684 und der 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 Semikolon getrennt, der letzte Wert ist jedoch nicht mit einem anderen versehen. Wenn Sie ein Semikolon an die Zeichenkettenform des Arrays anhängen (d. H. A; b; c wird a; b; c;), können Sie mit "x;" egal in welcher Position es sich befindet:

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

Für meinen Fall funktionierten die obigen Antworten nicht. Ich habe nach einem String in einem Array gesucht und ihn einem booleschen Wert zugewiesen. Ich habe die Antwort von @Anton Gogolev geändert, die Any()-Methode entfernt und das stringToCheck in die Contains()-Methode eingefügt.

bool = stringArray.Contains(stringToCheck);

versuchen Sie Folgendes, 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));

Versuche dies

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

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

Sie erhalten die Zeile mit der ersten Häufigkeit des gesuchten Textes.

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 beliebigen Element des Arrays 'lines' übereinstimmt.

Wenn stringArray eine große Anzahl von Zeichenfolgen mit variabler Länge enthält, sollten Sie ein Trie verwenden, um das Zeichenfolgenarray zu speichern und zu durchsuchen.

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

Wenn alle Zeichenfolgen in stringArray die gleiche Länge haben, ist es besser, nur eine HashSet anstelle einer Trie zu verwenden.

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 Schleife erforderlich ..

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

}