C＃长开关语句

Question

I've seen the articles on StackOverflow regarding c++ long switch statements, but c# is different in this regard.

Specifically, I would like to replace a hugely-long switch statement in c# code, where each case statement does the same thing, just the field name changes.

The code looks like this:

 case Fields.TRANSMITTERCONTACTPHONEEXT:
                {
                    int lengthNeeded = 0;
                    int currentLength = TransmitterContactTelephoneExtension.Length;
                    int lengthRequired = TransmitterContactTelephoneExtensionLength;
                    if (currentLength < lengthRequired)
                    {
                        lengthNeeded = lengthRequired - currentLength;
                        for (int i = 0; i < lengthNeeded; i++)
                        {
                            TransmitterContactTelephoneExtension += " ";
                        }
                    }
                } break;
            case Fields.TRANSMITTERFEIN:
                {
                    int lengthNeeded = 0;
                    int currentLength = TransmitterFEIN.Length;
                    int lengthRequired = TransmitterFEINLength;
                    if (currentLength < lengthRequired)
                    {
                        lengthNeeded = lengthRequired - currentLength;
                        for (int i = 0; i < lengthNeeded; i++)
                        {
                            TransmitterFEIN += " ";
                        }
                    }
                } break;

I'd like to just get this down to a single function that can figure out which field I mean without having to use a switch statement. Is there a way to pass in a variable containing the field name?

Answer 1

This just looks like the code for a string pad function repeated multiple times. You could just have

case Fields.TRANSMITTERCONTACTPHONEEXT:
     TransmitterContactTelephoneExtension = TransmitterContactTelephoneExtension.PadRight(TransmitterContactTelephoneExtensionLength, ' ');
     break;
    ...

Any time that you find yourself repeating code over and over, you probably can break it out into a separate function (if one does not already exist) and just call it with the right parameters.

And this also makes me wonder if you need the switch case statement at all, and not just a series of pad statements. But that is going further out (in scope) in your code. And your post does not give us enough info to go there.

Finally, somewhat applicable to your question, my rule of thumb (not originally mine, but I forget where I got it) is that if a method is more than a pageful (intentionally vague term), then I need to break it up into other separate methods. That allows me to look at a method and understand it without scrolling around. It also forces me to separate a longer process into smaller logical steps.

Answer 2

Place all the changeable values into arrays and index into it. Make sure the enum int values are the same as the data in the target arrays.

var current = (int) Fields.TRANSMITTERCONTACTPHONEEXT;

int lengthNeeded = 0;
int currentLength = LengthData[ current ] ;
int lengthRequired = RequiredData[current ];

if (currentLength < lengthRequired)
{
      lengthNeeded = lengthRequired - currentLength;
      for (int i = 0; i < lengthNeeded; i++)
      {
         Extensions[ current ] = Extensions[ current ] + " ";
      }
}

---

This post looks at the pattern of the operations in the switch and does not address any localized deficiencies of individual operations. Please look at each of the individual operations and where needed improve it for optimal operational efficiencies.

Answer 3

Declare the variables in advance, and use the switch only for the assignments that differ:

int currentLength;
int lengthRequired;

switch (whatever) {
case Fields.TRANSMITTERCONTACTPHONEEXT:
    currentLength = TransmitterContactTelephoneExtension.Length;
    lengthRequired = TransmitterContactTelephoneExtensionLength;
    break;
case Fields.TRANSMITTERFEIN:
    currentLength = TransmitterFEIN.Length;
    lengthRequired = TransmitterFEINLength;
    break;
default:
    throw new Exception(); // Without this, the compiler will complain about uninitialized variables
}

int lengthNeeded = 0;
if (currentLength < lengthRequired)
{
    lengthNeeded = lengthRequired - currentLength;
    for (int i = 0; i < lengthNeeded; i++)
    {
        TransmitterFEIN += " ";
    }
}

switch (whatever) {
case Fields.TRANSMITTERCONTACTPHONEEXT:
    TransmitterContactTelephoneExtension += " ";
    break;
case Fields.TRANSMITTERFEIN:
    TransmitterFEIN += " ";
    break;
}

Edit: OmegaMan's solution is way better if you have the option of replacing the variables with an array.

Answer 4

You really should break this out into a method. So that you are not duplicating code over and over. That is inefficient and can lead to potential errors when updating.

Also instead of looping you should make use of the PadRight() method on strings.

I would do this:

case Fields.TRANSMITTERCONTACTPHONEEXT:
     TransmitterContactTelephoneExtension = PadString(TransmitterContactTelephoneExtensionLength, TransmitterContactTelephoneExtension);
     break;
case Fields.TRANSMITTERFEIN:
     TransmitterFEIN = PadString(TransmitterFEINLength, TransmitterFEIN);
     break;


private string PadString(int requiredLen, string value)
{
     if (value == null) return String.Empty.PadRight(requiredLen, ' '); //Create an empty string when the value is null
     return value.PadRight(requiredLen, ' ');
}

Answer 5

To me it seems like the code we can't see needs some refactoring, but based on what we can see, I would recommend doing the following:

// 1. Have a class to hold your data
class FieldData
{
    public string Value { get; set; }
    public int LengthRequired { get; set; }

    public string RightPaddedValue
    {
        get { return Value.PadRight(LengthRequired, ' '); }
    }
}

// 2. Fill your data into a dictionary somehow... for example:
Dictionary<Fields, FieldData> fields = new Dictionary<Fields, FieldData>
{
    { 
        Fields.TRANSMITTERCONTACTPHONEEXT, 
        new FieldData {
            Value = TransmitterContactTelephoneExtension,
            LengthRequired = TransmitterContactTelephoneExtensionLength
        }
    },
    { 
        Fields.TRANSMITTERFEIN,
        new FieldData {
            Value = TransmitterFEIN,
            LengthRequired = TransmitterFEINLength
        }
    }
};

// 3. Then use the data from that dictionary in your code:
FieldData data = fields[selectedField];
data.RightPaddedValue; // use RightPaddedValue