looking alternative way for this switch case or any other solution

Question

I am doing an database update operation and updating some of the fields based on type being passed to the internal method with switch case statement, at the moment it has 4 case statements and it will grow bigger..

I am looking a way to convert this switch case to dictionary with key value pair or any kind of mechanism to implement inside method.

This is main method

  public async Task<MutationResponse> SetRequestStage(string requestStage, Guid requestId, MasterSectionEnum masterSectionEnum)
  {
        var request = _dbContext.Requests.SingleOrDefault(r => r.Id == requestId);
        var rs = _dbContext.RequestStages.SingleOrDefault(rs => rs.Name == requestStage);

        if (rs != null)
        {
            request.RequestStage = rs;

            if (rs.Name == "Approved")
            {
                switch (masterSectionEnum)
                {
                    case MasterSectionEnum.LOCALCODE:
                        await UpdateRevision<LocalCode>(request.DataId).ConfigureAwait(false);
                        break;
                    case MasterSectionEnum.NATIONALCODE:
                        await UpdateRevision<NationalCode>(request.DataId).ConfigureAwait(false);
                        break;
                    case MasterSectionEnum.GUIDELINES:
                        await UpdateRevision<Guideline>(request.DataId).ConfigureAwait(false);
                        break;
                    case MasterSectionEnum.LIBRARYA621:
                        await UpdateRevision<LibraryA621>(request.DataId).ConfigureAwait(false);
                        break;
                    case .....
                    case .....
                    default:
                        throw new ArgumentException($"SetRequestStage Error: invalid MasterSection {masterSectionEnum.ToString()}");
                }
            }
        }
        _dbContext.SaveChanges();
        return new MutationResponse();
    }

and this will be the enum

public enum MasterSectionEnum
{
    LOCALCODE,
    NATIONALCODE,
    GUIDELINES,
    SPACETYPE,
    LIBRARYA621 
   // this will grow bigger
}

and this will be the internal method that i am calling from above method

 private async Task UpdateRevision<T>(Guid id) where T : class, IAEIMaster, IRevisionData
 {
        var dbSet = this._dbContext.Set<T>();
        var code = dbSet.SingleOrDefault(c => c.Id == id);
        ......
        ......
        code.Revision = revision;
        code.IsApproved = true;
  }

could any one suggest on how to convert this switch case to alternative kind with key value pair or with types that would be very grateful to me.

many thanks in advance

Update : i am looking kind of below method, I am using dot net core with EF core

        var types = new Dictionary<string, string>();
        foreach(var item in types)
        {
            if(item.Key == "enum value")
            {
                await UpdateRevision<item.value>(request.DataId).ConfigureAwait(false);
            }
        }

Answer 1

Instead of passing in the parameter MasterSectionEnum, change your method to accept a type parameter. Then just use that generic type in a single call of UpdateRevision.

public async Task<MutationResponse> SetRequestStage<SectionType>(
    string requestStage, 
    Guid requestId
) {

    ...
    await UpdateRevision<SectionType>(request.DataId).ConfigureAwait(false);
    ....

}

If all valid types of SectionType share an interface or are derived from the same class, then you can take it further and add a constraint to the SectionType and avoid having to handle bad types at runtime.

---

Edit:

So SetRequestStage can't be generic huh? Well, the inclination to make it generic stems from the fact that it depends on UpdateRevision, which is generic. This in turn depends on DbContext.Set(). And you're using a generic version of it. But the good news is that there seems to be a non-generic version of it that accepts a type variable as a parameter. So:

async Task UpdateRevision<T>(
    Guid id,
    Type t
) where T : class, IAEIMaster, IRevisionData {

    var dbSet = this._dbContext.Set(t);
    ...

}

And then:

public async Task<MutationResponse> SetRequestStage(
    string requestStage, 
    Guid requestId,
    Type SectionType
) {

    ...
    await UpdateRevision(request.DataId, SectionType).ConfigureAwait(false);
    ....

}

I don't know what your UI looks like. But, generically:

var dic = new Dictionary<MasterSectionEnum, Type> {
    { MasterSectionEnum.LOCALCODE, typeof(LocalCode) },
    { MasterSectionEnum.NATIONALCODE, typeof(NationalCode) },
    ...
};

public async someUiRelatedMethod(
    string reqStage,
    Guid reqId,
    MasterSectionEnum sectionType
) {

    await SetRequestStage(reqStage, reqId, dic[sectionType]);

}

Sorry if the syntax on the latter isn't quite right. But you get the idea.

Answer 2

You can try this:

public enum MasterSectionEnum
{
    LOCALCODE,
    NATIONALCODE
}

public sealed class LocalCode { }
public sealed class NationalCode { }

public sealed class Program
{
    private static readonly Dictionary<MasterSectionEnum, Func<Guid, Task>> Dictionary
        = new Dictionary<MasterSectionEnum, Func<Guid, Task>>();

    static Program()
    {
        Dictionary[MasterSectionEnum.LOCALCODE] = UpdateRevision<LocalCode>;
        Dictionary[MasterSectionEnum.NATIONALCODE] = UpdateRevision<NationalCode>;
    }

    public static async Task SetRequestStage(MasterSectionEnum masterSectionEnum)
    {
        await Dictionary[masterSectionEnum].Invoke(Guid.NewGuid());
    }

    private static Task UpdateRevision<T>(Guid id) where T : class
    {
        Console.WriteLine(typeof(T));
        return Task.CompletedTask;
    }

    public static async Task Main()
    {
        await SetRequestStage(MasterSectionEnum.LOCALCODE);
        await SetRequestStage(MasterSectionEnum.NATIONALCODE);

        Console.ReadKey();
    }
}

Result:

LocalCode
NationalCode