如何重构Switch语句

Question

I am trying to refactor the mother of all switches and am not really sure how to do it. Here is the existing code:

    private void SetPrepareFiles(
                  ObservableCollection<PrepareElement> prepareElements)
    {
        DateTime fileLoadDate = DateTime.Now;


        string availabilityRequestFile = string.Empty;
        string infrastructureFile = string.Empty;
        string gsQualityFile = string.Empty;
        string pvdnpProducedFile = string.Empty;
        string docFile = string.Empty;
        string actualCurrentStateFile = string.Empty;
        string actualIpPlanFile = string.Empty;


        foreach (var prepareElement in prepareElements)
        {
            switch (prepareElement.MappingName)
            {
                case "AvailabilityRequest":
                    availabilityRequestFile = prepareElement.FileName;
                    break;
                case "SystemInformation":
                    docFile = prepareElement.FileName;
                    break;
                case "ITStatus":
                    infrastructureFile = prepareElement.FileName;
                    break;
                case "ActualIPPlan":
                    actualIpPlanFile = prepareElement.FileName;
                    break;
                case "ActualCurrentState":
                    actualCurrentStateFile = prepareElement.FileName;
                    break;
                case "Produced":
                    pvdnpProducedFile = prepareElement.FileName;
                    break;
                case "Quality":
                    QualityFile = prepareElement.FileName;
                    break;
            }

        }   


        var fc = new FilesConverter.FilesConverter();           
        fc.SetCommonFiles(availabilityRequestFile, actualCurrentStateFile,
                               actualIpPlanFile, fileLoadDate);         

    }

How would I refactor this Switch to a Dictionary

Answer 1

Actually the compiler refactors the switch in your code into a dictionary, because strings cannot be a part of a switch by default. The compiler puts all of your strings into a dictionary and gives each of them a unique number.

Dictionary<String, Int32> _CompilerGeneratedList = .... {
    { "AvailabilityRequest" , 1 }
};

You switch looks now like this:

Int32 value;
if (_CompilerGeneratedList.TryGetValue(myString, out value))
{
    switch (value) { ... }
}

Refactoring

Personally i would keep the the statement you did because refactoring doesn't makes it so much better but you could do it this way:

// Nested Private class
class DataHolder
{
    public String AvailabilityRequestFile { get; set; }
    public String PvdnpProducedFile { get; set; }
}

static Dictionary<String, Action<String, DataHolder>> DataUpdateActions = new Dictionary<String, Action<String, DataHolder>>
{
    { "AvailabilityRequest", (s,d) => d.AvailabilityRequestFile = s; }
    { "Produced", (s,d) => d.PvdnpProducedFile = s; }
};

Now you can call it this way:

DataHolder holder = new DataHolder();
foreach (var prepareElement in prepareElements)
{
    // Do this with try get value to prevent errors
    DataUpdateActions[prepareElement.MappingName](s, holder);

    var fc = new FilesConverter.FilesConverter();           
    fc.SetCommonFiles(holder.AvailabilityRequestFile, holder.ActualCurrentStateFile,
                           holder.ActualIpPlanFile, holder.FileLoadDate); 
}

Answer 2

Most switch statements are converted into Dictionary objects by the compiler. If you would like to do so yourself it's simple enough:

var dictionary = new Dictionary<string, Action>()
{
    {"AvailabilityRequest", prepareElement => availabilityRequestFile = prepareElement.FileName},
    {"SystemInformation", prepareElement => docFile = prepareElement.FileName}
    //TODO add the others
};

Given that you're accessing local variables in the Action , you'll need to declare the Dictionary inside of the method body. If you weren't, you could create a static dictionary to avoid re-creating it.

Then the body of your for loop becomes:

dictionary[prepareElement.MappingName](prepareElement);

Answer 3

What about

Dictionary<string, string> fileMappings =
   prepareElements.ToDictionary(e => e.MappingName, e => e.FileName);