Comment puis-je transformer cette méthode de 12 lignes en une expression LINQ à une ligne?

Question

Comment puis-je remplacer ConvertListToString(extensions) par une instruction LINQ élégante?

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 

namespace TestExtn2343 
{ 
    class Program 
    { 
     public static void Main(string[] args) 
     { 
      string[] files = { "test.txt", "test2.txt", 
           "test.as", "notes.doc", 
           "data.xml", "test.xml", 
           "test.html", "notes.txt", 
           "test.xls" }; 

      List<string> extensions = (from file in files 
          let index = file.LastIndexOf('.') + 1 
          select file.Substring(index)).Distinct().ToList<string>(); 

      Console.WriteLine("The kinds of file extensions used are {0}.", ConvertListToString(extensions)); 
      Console.ReadLine(); 
     } 

     public static string ConvertListToString(List<string> list) { 
      StringBuilder sb = new StringBuilder(); 
      int count = 1; 
      foreach (var listItem in list) 
      { 
       sb.Append(listItem.ToUpper()); 
       if (count != list.Count) 
        sb.Append(", "); 
       count++; 
      } 
      return sb.ToString(); 
     } 

    } 
} 

Answer 1

var s = string.Join(", ", files.Select(file => Path.GetExtension(file)) 
    .Distinct(StringComparer.InvariantCultureIgnoreCase).ToArray()); 

Answer 2

Voilà comment:

String s = String.Join(", ", (from extension in extensions select extension.ToUpper()).ToArray()); 

Remarque, je ne reviendrais probablement pas écrire cela comme une ligne plutôt comme ceci:

String s = String.Join(", ", 
    (from extension in extensions 
    select extension.ToUpper()).ToArray()); 

Si vous ne me dérange pas seulement aller pour les méthodes d'extension Linq directement, au lieu de la syntaxe de requête Linq, vous pouvez utiliser ceci:

String s = String.Join(", ", extensions.Select(e => e.ToUpper()).ToArray()); 

Une autre variante serait de simplement appeler ToUpper sur la chaîne finale à la place:

String s = String.Join(", ", extensions.ToArray()).ToUpper(); 

Et enfin, dans .NET 4.0, String.Join soutient enfin IEnumerable<String> directement, donc cela est possible:

String s = String.Join(", ", extensions).ToUpper(); 

Notez que selon votre question, cela pourrait entraîner des doublons. Considérez ce qui se passerait si votre liste originale de noms de fichiers contenait à la fois "filename.txt" et "filename.TXT", elles seraient comptées comme deux extensions distinctes.

L'appel à ToUpper doit être déplacé avant l'appel à Distinct pour résoudre ce problème.

Au lieu de l'expression Linq originale + code, je réécrire toute chose à ceci:

String[] distinctExtensions = files 
    .Select(fileName => Path.GetExtension(fileName).ToUpper()) 
    .Distinct() 
    .ToArray(); 
String distinctExtensionsAsString = String.Join(", ", distinctExtensions); 

Si vous ajoutez la méthode utilitaire suivante à votre bibliothèque de code, vous pouvez simplifier davantage:

public static class StringExtensions 
{ 
    public static String Join(this IEnumerable<String> elements, String separator) 
    { 
     if (elements is String[]) 
      return String.Join(separator, (String[])elements); 
     else 
      return String.Join(separator, elements.ToArray()); 
    } 
} 

puis votre code peut ressembler à ceci:

String distinctExtensionsAsString = files 
    .Select(fileName => Path.GetExtension(fileName).ToUpper()) 
    .Distinct() 
    .Join(", "); 

Answer 3

Que diriez-vous ceci:

String output = String.Join(", ",(from file in files 
    let index = file.LastIndexOf('.') + 1 
    select file.Substring(index)).Distinct().ToArray<string>()); 

Answer 4

Que diriez-vous ... ce

public static string ConvertListToString(List<string> list) 
{ 
    return list.Aggregate((x, y) => x + ", " + y).ToUpper(); 
} 

Ce qu'il fait dans une ligne, et je l'ai déplacé la « ToUpper » out sur la dernière chaîne de sorte qu'il est seulement appelé une fois. De toute évidence, vous pouvez alors jeter la méthode ConvertListToString et inline si vous le souhaitez.