Vérifier la chaîne pour voir si une chaîne dans un tableau de chaînes s'y trouve

Question

J'ai une liste de chaînes générique: List listOfString = new List();

Je puis ajouter 4 cordes à cette liste:

 listOfString .Add("test1"); 
     listOfString .Add("test2"); 
     listOfString .Add("test3"); 
     listOfString .Add("test4"); 

Je veux vérifier vérifier une variable de chaîne si elle contient un élément dans mon tableau de chaînes est présent.

J'ai vu la méthode 'Any' décrite mais cela ne compile pas en C# puis-je le faire uniquement dans une boucle for?

Merci.

Answer 1

Je pense que la question est plus à propos de tester si une chaîne contient des éléments du tableau.

devrait ressembler à ceci en pseudo-code (je ne suis pas familier avec .Net)

function StringContainsAny(String toTest, List<String> tests) 
{ 
    foreach(String test in tests) 
    { 
     if(toTest.Contains(test)) 
     { 
      return test; 
     } 
    } 
    return null; 
} 

Answer 2

Si je comprends bien votre question, avez-vous besoin:

public static bool ContainsAnyElement(IList<string> l, string input) 
    { 
     foreach (var s in l) 
     { 
      if (l.Contains(s)) 
       return true; 
     } 
     return false; 
    } 

    // Usage 

    IList<string> l = new List<string>() { "a", "b", "c" }; 

    string test = "my test string with aa bbb and cccc"; 

    Console.WriteLine(ContainsAnyElement(l, test)); 

Answer 3

Vous pourriez utilisez la fonction Any si vous utilisez les extensions de méthode LINQ (.net 3.5). comme ceci:

var foobar = "foobar"; 
new[] {"foo", "bar"}.Any(foobar.Contains); 

mais si vous dissasemble Tout ce que vous verrez est juste une boucle de toute façon.

bo public static

public static bool Any<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) 
{ 
    if (source == null) 
    { 
     throw Error.ArgumentNull("source"); 
    } 
    if (predicate == null) 
    { 
     throw Error.ArgumentNull("predicate"); 
    } 
    foreach (TSource local in source) 
    { 
     if (predicate(local)) 
     { 
      return true; 
     } 
    } 
    return false; 
} 

Donc, si vous ne voulez pas utiliser la fonction NET 3.5 ci-dessus en .Net 2.0 ressemblerait à ceci:

public static class Utilities 
{ 
    public delegate bool AnyPredicate<T>(T arg); 
    public static bool Any<TSource>(IEnumerable<TSource> source, AnyPredicate<TSource> predicate) 
    { 
     if (source == null) 
     { 
      throw new ArgumentException("source"); 
     } 
     if (predicate == null) 
     { 
      throw new ArgumentException("predicate"); 
     } 
     foreach (TSource local in source) 
     { 
      if (predicate(local)) 
      { 
       return true; 
      } 
     } 
     return false; 
    } 
} 

utilisation

:

var foobarlist = new[]{"foo", "bar"}; 
    var foobar = "foobar"; 
    var containsfoobar = Utilities.Any(foobarlist, foobar.Contains); 

J'espère que cela aide.