variables Utilisation à la place du nom de la fonction

Question

J'utilise ce qui suit en ce moment:

foreach (string file in files) { 
    switch (filetype.Value) { 
     case "ReadFile": 
      ReadFile(file); 
      break; 
     case "ReadMSOfficeWordFile": 
      ReadMSOfficeWordFile(file); 
      break; 
     case "ReadMSOfficeExcelFile": 
      ReadMSOfficeExcelFile(file); 
      break; 
     case "ReadPDFFile": 
      ReadPDFFile(file); 
      break; 
    } 
} 

Il fonctionne, mais il se sent un peu mal. La façon Python serait quelque chose comme ceci:

foreach string file in files: 
    filetype.Value(file) 

J'ai vraiment du mal à imaginer que C# ne peut pas faire quelque chose comme ça. Il se peut que mes compétences Google soient mauvaises, mais je n'arrive pas à le comprendre.

SOLUTION

public static readonly IDictionary<string, Action<string>> FileTypesDict = new Dictionary<string,Action<string>> { 
    {"*.txt", ReadFile}, 
    {"*.doc", ReadMSOfficeWordFile}, 
    {"*.docx", ReadMSOfficeWordFile}, 
    {"*.xls", ReadMSOfficeExcelFile}, 
    {"*.xlsx", ReadMSOfficeExcelFile}, 
    {"*.pdf", ReadPDFFile}, 
}; 

 

foreach (KeyValuePair<string, Action<string>> filetype in FileTypesDict) { 
    string[] files = Directory.GetFiles(FilePath, filetype.Key, SearchOption.AllDirectories); 
    //System.Reflection.MethodInfo ReadFileMethod = ReadFile.GetType().GetMethod(filetype.Value); 
    foreach (string file in files) { 
     FileTypesDict[filetype.Key](file); 
    } 
} 

Answer 1

Vous pouvez le faire avec une certaine préparation à l'aide des délégués, comme ceci:

private static readonly IDictionary<string,Action<string>> actionByType = 
    new Dictionary<string,Action<string>> { 
     {"ReadFile", ReadFile} 
    , {"ReadMSOfficeWordFile", ReadMSOfficeWordFile} 
    , {"ReadMSOfficeExcelFile", ReadMSOfficeExcelFile} 
    , {"ReadPDFFile", ReadPDFFile} 
    }; 

Quand il est temps d'appeler votre action , faites comme suit:

actionByType[actionName](file); 

Answer 2

Vous pouvez garder un Dictionary des délégués, comme la façon la plus simple:

Dictionary<string, Action<string>> fileReaders = new Dictionary<string, Action<string>>() { 
    {"ReadFile", ReadFile}, 
    {"ReadOfficeWordFile", ReadOfficeWordFile}, 
    {"ReadOfficeExcelFile", ReadOfficeExcelFile}, 
    {"ReadPDFFile", ReadPDFFile} 
}; 

Ensuite, appelez comme ceci:

fileReaders[fileType.Value](file); 

Selon ce que vos méthodes de retour, vous devrez peut-être pour changer le type du délégué (Action<string> signifie aussi void something(string someparam) comme signature de méthode, par exemple).

Answer 3

Vous pouvez utiliser un délégué:

Action<string> action; 
switch (filetype.Value) { 
    case "ReadFile": 
    action = ReadFile; 
    break; 
    case "ReadMSOfficeWordFile": 
    action = ReadMSOfficeWordFile; 
    break; 
    case "ReadMSOfficeExcelFile": 
    action = ReadMSOfficeExcelFile; 
    break; 
    case "ReadPDFFile": 
    action = ReadPDFFile; 
    break; 
    default: 
    throw new NotImplementedException("Unhandled file type '"+filetype.Value+"'."); 
} 
foreach (string file in files) { 
    action(file); 
} 

Answer 4

Vous pouvez également utiliser la réflexion (si vous êtes d'accord avec les différents frais généraux qui peuvent apporter) Cocher cette solution

Espoir qui a aidé

Answer 5

Je crois que ce que vous cherchez aura besoin d'un refactoring de votre code. Tous vos «cas» (TextFile, MSOfficeWordFile, MSOfficeExcelFile, PdfFile) doivent être leurs propres classes qui implémentent une interface unique.

Votre interface doit s'appeler quelque chose comme "IReadableFile" et spécifier une méthode nommée "ReadFile()".

Chaque classe devrait avoir sa propre mise en œuvre de "ReadFile()"

Exemple:

public interface IReadableFile 
{ 
    void ReadFile(); 
} 

---

public class MSOfficeWordFile : IReadableFile 
{ 
    public void ReadFile() 
    { 
     ReadMSOfficeWordFile(file); 
    } 
} 

---

foreach(IReadableFile file in files) 
    file.ReadFile(); 

code

peut contenir des erreurs, mais je J'espère que vous avez l'idée.

Answer 6

Si vous êtes à la recherche d'un moyen d'éviter le mappage explicite des noms de méthode à des valeurs de chaîne, vous pouvez utiliser la réflexion pour faire appel de méthode dynamique (cela suppose filetype.Value est de type String)

String method_name = String.Empty; 
foreach (string file in files) { 
    method_name = filetype.Value; 
    System.Reflection.MethodInfo method = this.GetType().GetMethod(method_name); 
    method.Invoke(this, new object[]{file}); 
}