Is there any easy way of sorting c# switch case statements?

Question

I'm looking for an automated way of sorting a large block of case statments.

switch (id) {
    case RadGridStringId.ClearSortingMenuItem: return "Annuler les tris";
    case RadGridStringId.ConditionalFormattingMenuItem: return "Formatage conditionnel";
    case RadGridStringId.GroupByThisColumnMenuItem: return "Grouper par cette colonne";
    case RadGridStringId.UngroupThisColumn: return "Dégrouper cette colonne";
    case RadGridStringId.ColumnChooserMenuItem: return "Masqueur de colonnes";
    case RadGridStringId.HideMenuItem: return "Masquer cette colonne";

    case RadGridStringId.ConditionalFormattingBtnApply: return "Appliquer";
    case RadGridStringId.ColumnChooserFormCaption: return "Masqueur de colonnes";
    case RadGridStringId.ColumnChooserFormMessage: return "Ajouter ici une colonne\npour la faire disparaitre\ntemporairement de la vue";
    case RadGridStringId.GroupingPanelDefaultMessage: return "Ajouter ici une colonne pour faire un regroupement par cette colonne";
    case RadGridStringId.GroupingPanelHeader: return "Groupe par";
    case RadGridStringId.ClearValueMenuItem: return "Effacer la Valeur";
    case RadGridStringId.ConditionalFormattingContains: return "Contient [Valeur1]";
    case RadGridStringId.ConditionalFormattingDoesNotContain: return "Ne contient pas [Valeur1]";
    case RadGridStringId.ConditionalFormattingEndsWith: return "Finit par [Valeur1]";
    case RadGridStringId.ConditionalFormattingEqualsTo: return "Est égal à [Valeur1]";
    case RadGridStringId.ConditionalFormattingIsBetween: return "Est compris entre [Valeur1] et [Valeur2]";
    case RadGridStringId.ConditionalFormattingIsGreaterThan: return "Est supérieur à [Valeur1]";
    case RadGridStringId.ConditionalFormattingIsGreaterThanOrEqual: return "Est supérieur ou égal à [Valeur1]";
    case RadGridStringId.ConditionalFormattingIsLessThan: return "Est inférieur à [Valeur1]";
    case RadGridStringId.ConditionalFormattingIsLessThanOrEqual: return "Est inférieur ou égal à [Valeur1]";
    case RadGridStringId.ConditionalFormattingIsNotBetween: return "Non compris entre [Valeur1] et [Valeur2]";
    case RadGridStringId.ConditionalFormattingIsNotEqualTo: return "Est différent de [Valeur1]";
    case RadGridStringId.ConditionalFormattingStartsWith: return "Commence par [Valeur1]";
    case RadGridStringId.ConditionalFormattingRuleAppliesOn: return "La règle s'applique au champ:";
    case RadGridStringId.ConditionalFormattingChooseOne: return "[Choisir un type]";
    case RadGridStringId.NoDataText: return "Pas de données à afficher";

    default:
        return base.GetLocalizedString(id);
}

Does anyone know a tool, add-on or extension for doing that in Visual Studio 2013/2015?

Update on 2015-11-12

Additional infos: This is only a design-time problem for me. I'm using Telerik controls. Unfortunately this controls doesn't provide any out-of-the-box translation of their controls. They only provide a translation mechanism.

I can find different files for different languages on the net (e. g. this here). But they are incompleteted and the order of the case statements in this files are different.

To see differences in these files a sorted switch statement would make life much easier :)

PS: An additional nice to have feature were a way to extend the switch of currently missing/unused enum values.

Regards, Daniel

Answer 1

As mentioned in the comments, you could simply copy the lines to Excel, sort the rows alphabetically, and paste them back in the code. However, this large switch statement will be a pain to maintain later on. You should consider another approach, such as using a Dictionary.

In the following code, a dictionary with all the texts are created

private static Dictionary<RadGridStringId, string> texts;

private static void InitializeTexts()
{
    texts = new Dictionary<RadGridStringId, string>();
    texts[RadGridStringId.ClearSortingMenuItem] = "Annuler les tris";
    texts[RadGridStringId.ConditionalFormattingMenuItem] = "Formatage conditionnel";
    texts[RadGridStringId.GroupByThisColumnMenuItem] = "Grouper par cette colonne";
    texts[RadGridStringId.UngroupThisColumn] = "Dégrouper cette colonne";
    texts[RadGridStringId.ColumnChooserMenuItem] = "Masqueur de colonnes";
    texts[RadGridStringId.HideMenuItem] = "Masquer cette colonne";
    texts[RadGridStringId.ConditionalFormattingBtnApply] = "Appliquer";
    texts[RadGridStringId.ColumnChooserFormCaption] = "Masqueur de colonnes";
    texts[RadGridStringId.ColumnChooserFormMessage] =
        "Ajouter ici une colonne\npour la faire disparaitre\ntemporairement de la vue";
    texts[RadGridStringId.GroupingPanelDefaultMessage] =
        "Ajouter ici une colonne pour faire un regroupement par cette colonne";
    texts[RadGridStringId.GroupingPanelHeader] = "Groupe par";
    texts[RadGridStringId.ClearValueMenuItem] = "Effacer la Valeur";
    texts[RadGridStringId.ConditionalFormattingContains] = "Contient [Valeur1]";
    texts[RadGridStringId.ConditionalFormattingDoesNotContain] = "Ne contient pas [Valeur1]";
    texts[RadGridStringId.ConditionalFormattingEndsWith] = "Finit par [Valeur1]";
    texts[RadGridStringId.ConditionalFormattingEqualsTo] = "Est égal à [Valeur1]";
    texts[RadGridStringId.ConditionalFormattingIsBetween] = "Est compris entre [Valeur1] et [Valeur2]";
    texts[RadGridStringId.ConditionalFormattingIsGreaterThan] = "Est supérieur à [Valeur1]";
    texts[RadGridStringId.ConditionalFormattingIsGreaterThanOrEqual] = "Est supérieur ou égal à [Valeur1]";
    texts[RadGridStringId.ConditionalFormattingIsLessThan] = "Est inférieur à [Valeur1]";
    texts[RadGridStringId.ConditionalFormattingIsLessThanOrEqual] = "Est inférieur ou égal à [Valeur1]";
    texts[RadGridStringId.ConditionalFormattingIsNotBetween] = "Non compris entre [Valeur1] et [Valeur2]";
    texts[RadGridStringId.ConditionalFormattingIsNotEqualTo] = "Est différent de [Valeur1]";
    texts[RadGridStringId.ConditionalFormattingStartsWith] = "Commence par [Valeur1]";
    texts[RadGridStringId.ConditionalFormattingRuleAppliesOn] = "La règle s'applique au champ:";
    texts[RadGridStringId.ConditionalFormattingChooseOne] = "[Choisir un type]";
    texts[RadGridStringId.NoDataText] = "Pas de données à afficher";
}

A simple getter that initializes the dictionary if it wasn't already, and returns the string.

private static string getText(RadGridStringId id)
{
    if (texts == null)
    {
        InitializeTexts();
    }
    if (texts.ContainsKey(id))
    {
        return texts[id];
    }
    else
    {
        return string.Empty; // or base.GetLocalizedString(id);
    }
}

Then you simply use the method:

private static void Main(string[] args)
{
    RadGridStringId id = RadGridStringId.GroupingPanelHeader;
    string test = getText(id);
    Console.WriteLine(test); //prints: "Groupe par"
}