it-swarm.com.de

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

Ich möchte mit C # prüfen, ob ein Zeichenfolgenwert ein Word 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 Zeichenfolgewert für 'stringToCheck' ein Word im Array enthält?

228
Theomax

so kannst du es machen:

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

UPDATE: Möglicherweise suchen Sie nach einer besseren Lösung. Lesen Sie die Antwort von @Anton Gogolev, die LINQ verwendet.

119
Abdel Raoof

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))
724
Anton Gogolev

Versuche dies:

Keine Notwendigkeit, LINQ zu verwenden

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

Verwenden Sie einfach die linq-Methode:

stringArray.Contains(stringToCheck)

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

29
Legolas21

Einfachste und probeweise.

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

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

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;
3
Jun Zheng
string strName = "vernie";
string[] strNamesArray = { "roger", "vernie", "joel" };

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

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

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))
1
Scotty.NET

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

Ich würde Linq verwenden, aber es geht noch durch:

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

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

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

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

stringArray.Any(s => stringToCheck.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) > -1)
0
Shady Sirhan
public bool ContainAnyOf(string Word, string[] array) 
    {
        for (int i = 0; i < array.Length; i++)
        {
            if (Word.Contains(array[i]))
            {
                return true;
            }
        }
        return false;
    }
0
nakisa

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

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);
0
Matthew Miranda

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

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.

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

0
Pabitra Dash

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

Einfache Lösung, keine linq erforderlich

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

0
user5789849
int result = Array.BinarySearch(list.ToArray(), typedString, StringComparer.OrdinalIgnoreCase);
0
amit jha

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

}
0
Amjad Abu Saa