Comment obtenir une liste de chaînes en utilisant linq?

Puisque vous avez une plage à indexer, vous pouvez l'utiliser avec LINQ pour extraire les éléments:

var sl = new ArraySegment<string>(folder_list, from-1, to-from+1).ToArray();

Mais il serait beaucoup plus efficace d'utiliser ArraySegment à la place :

var sublist = Enumerable.Range(from-1, to-from+1).Select(i => folder_list[i]).ToArray();

Pour chaque nom de dossier, extrayez la clé, analysez la clé en un nombre et ne conservez que le nom du dossier si le nombre est compris entre min et max

En utilisant des méthodes d'extension. Voir méthodes d'extension démystifiées

IEnumerable<string> folderNames = ...
IEnumerable<string> folderNamesWithinRange = folderNames.WhereFolderKeyBetween(3, 7);
    

Utilisation :

public string ExtractKeyText(this string folderName)
{
     // TODO: decide what to do if folderName == null

     // depending on your actual folder name.
     // is it really just "Folder00001" etc?
     return folderName.SubString(6);

     // if more difficult folderNames, consider using Regular Expressions
}

public IEnumerable<string> WhereFolderKeyBetween(
    this IEnumerable<string> folders,
    int minKey,
    int maxKey)
{
    // TODO: decide what to do if folders == null, or minKey > maxKey
    return folders.Where(folder => 
    {
        string keyTxt = folder.ExtractKeyText();
        return int.TryParse(keyTxt, out int key)
            && minKey <= key && key <= maxKey;
    });
};
        

merci beaucoup à tous pour les réponses. Désolé pour mon anglais :(

Je ne peux pas expliquer correctement le problème ... En gros, je reçois une liste fixe de dossiers que je dois compresser et envoyer par e-mail. Comme le serveur SMTP a des limites de taille de pièce jointe, je suis obligé de diviser la liste des dossiers en plusieurs fichiers zip, mais les dossiers LIST peuvent ne pas être consécutifs. Exemple:

private String[] get_sub_list_folders(Int32 since, Int32 to, String[] folder_list)
{
  var result = from folder in folder_list
               where (Int32.Parse(folder.Substring(8)) >= since && Int32.Parse(folder.Substring(8)) <= to)
               select folder;

  return (result.ToList().ToArray());
}

private void zip_folders()
{
  const String folder_pattern = "ABCDEF";
  const Int32 folders_in_zip = 5000;

  // Create list of all folder
  String[] folder_list = Directory.GetDirectories(".", folder_pattern + "*", SearchOption.TopDirectoryOnly);

  // Just in case order by name 
  Array.Sort(folder_list);

  Int32 folders_count = folder_list.Length;
  Int32 from = 1;
  Int32 to = folders_in_zip;

  // Build a chunk of the folder list 
  while (folders_count > 0)
  {
    // Make a subset fixed folder list
    String[] zip_folders_list = get_sub_list_folders(from, to, folder_list);

    // Build zip name
    String zip_name = String.Format("{0}{1:0000000}_{0}{2:0000000}.zip", folder_pattern, from, to);

    // Create zip 
    zip.create(zip_folders_list, zip_name);

    from += folders_in_zip;
    to += folders_in_zip;
    folders_count -= folders_in_zip;
  }
}

};

Donc, si je veux la liste de 1 à 3 je devrais obtenir "ABCDEF000001", "ABCDEF000002"

Ma solution est similaire à celle que j'implémente Harald et John Wu

var folder_list = new String[] {
"ABCDEF000001", 
"ABCDEF000002", 
"ABCDEF000004", 
"ABCDEF000005",
"ABCDEF000007",