可以用C＃切换这些语句吗？

Question

Possible to C# switch these statements? I am not bright enough to see the possibility.

        if (sortExpression.IndexOf("companyCode", StringComparison.OrdinalIgnoreCase) >= 0)
        {
            sortExpression += ", costCenter, acc_code";
        }
        if (sortExpression.IndexOf("costCenter", StringComparison.OrdinalIgnoreCase) >= 0)
        {
            sortExpression += ", companyCode, acc_code";
        }
        if (sortExpression.IndexOf("acc_code", StringComparison.OrdinalIgnoreCase) >= 0)
        {
            sortExpression += ", companyCode, costCenter";
        }
        {
            //default, everything else.
        }

Answer 1

You can certainly reduce the code repetition.

Try this:

var map = new Dictionary<string, string>()
{
    { "companyCode", ", costCenter, acc_code" },
    { "costCenter", ", companyCode, acc_code" },
    { "acc_code", ", companyCode, costCenter" },
};

var value =
    map
        .Where(x => sortExpression.IndexOf(x.Key, StringComparison.OrdinalIgnoreCase) >= 0)
        .Select(x => x.Value)
        .FirstOrDefault();

if (value != null)
{
    sortExpression += value;
}
else
{
    //default, everything else.
}

Answer 2

No, because you are testing different variables to a common value. Switch statements test a common variable to different values. To make a switch statement work in your case every if statement would have to be comparing the same variable.
ie

    if (sortExpression.IndexOf("companyCode", StringComparison.OrdinalIgnoreCase) >= 1)
    {
        sortExpression += ", costCenter, acc_code";
    }
    if (sortExpression.IndexOf("companyCode", StringComparison.OrdinalIgnoreCase) >= 2)
    {
        sortExpression += ", companyCode, acc_code";
    }
    if (sortExpression.IndexOf("companyCode", StringComparison.OrdinalIgnoreCase) >= 3)
    {
        sortExpression += ", companyCode, costCenter";
    }
    {
        //default, everything else.
    }

As you can see all of the variables are comparing sortExpression.IndexOf("companyCode", StringComparison.OrdinalIgnoreCase) to different values, rather than the other way around.

Answer 3

I do not think this is doing what you want.
In first if you search for "companyCode" and add 2 other fields if it exists.
So when first if is true, than other 2 ifs will be true as you will add other fields inside first if.

You could change this to "switch" if initially sortExpression would have single field.

switch (sortExpression)
{
    case "companyCode":
        sortExpression += ", costCenter, acc_code";
        break;
    case "costCenter":
        sortExpression += ", companyCode, acc_code";
        break;
    case "acc_code":
        sortExpression += ", companyCode, costCenter";
        break;
    default:
        //default, everything else.
        break;
}

If not you could use something like this:

public string GetSortExpression(string sortExpression)
{
    List<string> requiredFields = new List<string>(new[] { "companyCode", "costCenter", "acc_code" });
    if (string.IsNullOrEmpty(sortExpression) // string is null or empty
        || !requiredFields.Any(x => sortExpression.IndexOf(x, StringComparison.OrdinalIgnoreCase) >= 0)) // string does not contain any of fields
    {
        sortExpression = "default, everything else";
    }
    else
    {
        List<string> fields =
        sortExpression.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim()).ToList();
        fields.AddRange(requiredFields.Except(fields));
        sortExpression = string.Join(", ", fields);
    }
    return sortExpression;
}

Testing:

[TestCase(null, "default, everything else")]
[TestCase("", "default, everything else")]
[TestCase("companyCode", "companyCode, costCenter, acc_code")]
[TestCase("costCenter", "costCenter, companyCode, acc_code")]
[TestCase("acc_code", "acc_code, companyCode, costCenter")]
[TestCase("acc_code, companyCode", "acc_code, companyCode, costCenter")]
[TestCase("acc_code, costCenter", "acc_code, costCenter, companyCode")]
public void GetSortExpressionTest(string initial, string exprectedResult)
{
    Assert.AreEqual(exprectedResult, GetSortExpression(initial));
}