foreach to linq avec comparaison guidée

Question

Je voudrais convertir foreach dans cette méthode en une expression linq. J'ai 2 try/catch parce que je ne peux pas toujours compter sur les chaînes qui sont passées dans la liste des guids ou guidToFind pour être des chaînes de guidage valides.

public static bool IsGuidInList(List<string> guids, string guidToFind) 
    { 
     try 
     { 
      var guid = new Guid(guidToFind.Trim()); 
      foreach (var g in guids) 
      { 
       try 
       { 
        var g2 = new Guid(g.Trim()); 
        if (g2 == guid) 
         return true; 
       } 
       catch {} // swallow exception 
      } 
     } 
     catch{} // swallow exception 
     return false; 
    } 

Answer 1

public static bool IsGuidInList(List<string> guids, string guidToFind) 
{ 
    try 
    { 
     var guid = new Guid(guidToFind.Trim()); 
     return 
      guids 
      .Select(x => 
      { 
       Guid result; 
       return Guid.TryParse(x, out result) ? (Guid?)result : null; 
      }) 
      .Where(x => x.HasValue) 
      .Any(x => x.Value == guid); 
    } 
    catch { } // swallow exception 
    return false; 
} 

Answer 2

var tg = Guid.Empty; 
    guids.Any(g=> g!= null 
     && Guid.TryParse(g.Trim(), out tg) && new Guid(g.Trim()) == guid) 

Answer 3

pas aussi laconique que l'autre solution, mais je trouve lisible

public static bool IsGuidInList(List<string> guids, string guidToFind) 
    { 
     Guid outGuid; 

     var inGuidToFind = Guid.TryParse(guidToFind, out outGuid) ? outGuid : Guid.Empty; 
     if (inGuidToFind == Guid.Empty) 
      return false; 

     var inGuids = new List<Guid>(); 
     guids.Where(i => Guid.TryParse(i, out outGuid)).ForEach(i => inGuids.Add(new Guid(i))); 

     return inGuids.Contains(inGuidToFind); 
    } 

Answer 4

Thx pour les grandes réponses, mais je suis allé avec la réponse Jason Boyds, mais avec un légère modification de la mienne pour se débarrasser du dernier essai/catch. J'ai couru ces tests avec les résultats que j'attendais:

• mauvaise chaîne guidToFind
• bonne chaîne de guidToFind, la liste de toutes les chaînes guid valides

• bonne chaîne de guidToFind, liste des chaînes guid principalement valides

  public static bool IsGuidInList(List<string> guids, string guidToFind) 
  { 
      Guid guid; 
      if (!Guid.TryParse(guidToFind.Trim(), out guid)) 
       return false; 
  
      return 
       guids 
        .Select(x => 
        { 
         Guid result; 
         return Guid.TryParse(x, out result) ? (Guid?)result : null; 
        }) 
        .Where(x => x.HasValue) 
        .Any(x => x.Value == guid); 
  } 
  

MISE à JOUR: Après les commentaires d'un examen de code avec la méthode ci-dessus, j'ai pu faire plus refinemen ts et voici le résultat:

public static bool IsGuidInList(IEnumerable<string> guids, string guidToFind) 
    { 
     Guid guid; 
     if (!Guid.TryParse(guidToFind.Trim(), out guid)) 
      return false; 

     return guids.Any(x => { Guid result; 
      Guid.TryParse(x, out result); 
      return result == guid; 
     }); 
    } 

Answer 5

Cette réponse est pas particulièrement différente des autres déjà affichés, mais je voudrais utiliser personnellement ceci:

public static bool ContainsGuid(this IEnumerable<string> guids, string guidToFind) 
    { 
     if (guids == null) throw new ArgumentNullException(nameof(guids)); 
     if (guidToFind == null) throw new ArgumentNullException(nameof(guidToFind)); 

     if (!Guid.TryParse(guidToFind, out var guid)) 
      throw new ArgumentException($"Could not convert '{guidToFind}' to a GUID"); 

     return guids 
      .Select(s => Guid.TryParse(s, out var result) ? (Guid?)result : null) 
      .Contains(guid); 
    } 

Les différences étant:

• méthode d'extension (préférence personnelle)
• nouvelles fonctionnalités C# par exemple « Résultat sur var » (préférence personnelle)
• valider explicitement les paramètres (dépend du comportement que vous recherchez, mais je suis un grand fan)

Le dernier point me conduit à un point général: Si votre programme prend en entrée une collection de chaînes qui sont censées être des GUID, pourquoi ne pas les valider à ce moment-là et garder un IEnumerable de Guid? Faites la même chose pour le GUID à trouver et le code devient:

IEnumerable<Guid> guidList = // validated elsewhere 
var found = guidList.Contains(guid);