Я хочу використовувати C #, щоб перевірити, чи містить рядок значення у рядковому масиві. Наприклад,

string stringToCheck = "text1text2text3";

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

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

}

Як я можу перевірити, чи значення рядка для 'stringToCheck' містить слово в масиві?

ось як це зробити:

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

ОНОВЛЕННЯ. Можливо, ви шукаєте кращого рішення. Зверніться до відповіді @Anton Gogolev нижче, в якій використовується 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))

Спробуйте це:

Не потрібно використовувати LINQ

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

Просто використовуйте метод linq:

stringArray.Contains(stringToCheck)

Найпростіший і зразковий спосіб.

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

Можливо, щось подібне:

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

Використання Linq та групи методів було б найшвидшим та компактним способом цього зробити.

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

Ви можете визначити свій 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();
        }
    }

Я використовую наступне в консольній програмі для перевірки аргументів

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

Я б використовував Linq, але це все ще можна зробити через:

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

Спробуйте:

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

Ви також можете зробити те ж саме , що і Антон Гоголів пропонує перевірити , якщо який - або пункт в stringArray1відповідає будь-якому елементу в stringArray2:

if(stringArray1.Any(stringArray2.Contains))

І так само всі елементи в stringArray1 відповідають усім елементам у stringArray2:

if(stringArray1.All(stringArray2.Contains))

stringArray.ToList().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));

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 для створення цього. (Примітка: перші 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) { 
    // ....
}

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

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

bFound встановлює значення true, якщо шуканий рядок збігається з будь-яким елементом масиву 'рядки'.

Спробуйте це

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

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

Він поверне вам рядок із першим впаданням тексту, який ви шукаєте.

Якщо 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;
}

Просте рішення, не вимагається linq

String.Join (",", масив) .Contains (Значення + ",");

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

Спробуйте це, не потрібно петлі ..

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

}

Щоб виконати наведені вище відповіді, для перевірки IgnoreCase використовуйте:

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

Для мого випадку вищезазначені відповіді не спрацювали. Я перевіряв наявність рядка в масиві і присвоював йому булеве значення. Я змінив відповідь @Anton Gogolev і видалив Any()метод і вклав stringToCheckвсередину Contains()методу.

bool = stringArray.Contains(stringToCheck);

Використання методів Find або FindIndex класу Array :

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

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

Я використовував наступний код, щоб перевірити, чи містить рядок який-небудь із елементів рядкового масиву:

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

Продемонстровано три варіанти. Я вважаю за краще третій як самий стислий.

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