C# 在枚举方面遇到了困难，有一种代码味道不好的感觉

Question

我很难弄清楚如何做到这一点，基本上我有一个应用程序，它使用枚举来确定此人所在的建筑物，然后他们属于哪个部门。

根据人员所在的部门，可以添加不同的组。我想让它只执行一次，直到他们关闭并重新打开应用程序，有点像白名单。

问题在于，当想要使用泛型方法时，枚举似乎是一个巨大的痛苦。

我能够找到一种方法来做到这一点，使用通用静态字典，但它看起来很糟糕，我不知道是否有我忽略的东西或者更简单的方法来做我想要的。

private async Task CheckWhiteList(PowerShell power, KeyValuePair<string, Enum> history)
        {
            switch ((Building)Model.BuildingSelectedIndex)
            {
                case Building.CaneRidge:
                    history = new KeyValuePair<string, Enum>(Model.UserID, (CaneRidgeSettings.Departments)Model.DepartmentSelectedIndex);
                    if (!WhiteList.Contains(history))
                    {
                        WhiteList.Add(history.Key, history.Value);
                        await power.InvokeAsync();
                    }
                    break;
                case Building.Carothers:
                    history = new KeyValuePair<string, Enum>(Model.UserID, (CarothersSettings.Departments)Model.DepartmentSelectedIndex);
                    if (!WhiteList.Contains(history))
                    {
                        WhiteList.Add(history.Key, history.Value);
                        await power.InvokeAsync();
                    }
                    break;
                case Building.CSC:
                    history = new KeyValuePair<string, Enum>(Model.UserID, (CSCSettings.Departments)Model.DepartmentSelectedIndex);
                    if (!WhiteList.Contains(history))
                    {
                        WhiteList.Add(history.Key, history.Value);
                        await power.InvokeAsync();
                    }
                    break;
                case Building.HQ:
                    history = new KeyValuePair<string, Enum>(Model.UserID, (HQSettings.Departments)Model.DepartmentSelectedIndex);
                    if (!WhiteList.Contains(history))
                    {
                        WhiteList.Add(history.Key, history.Value);
                        await power.InvokeAsync();
                    }
                    break;
                default:
                    break;
            }

请注意，关键是他们的用户 ID，我不想将用户可能选择错误部门或错误建筑物的情况列入白名单。这就是为什么它必须匹配两个值。

Answer 1

当我看到重复时，我通常会尝试将代码拉出到辅助函数中。

我看到这种模式重复了几次：

case BUILDING:
    history = new KeyValuePair<string, Enum>(Model.UserID, (DEPARTMENTSETTINGS.Departments)Model.DepartmentSelectedIndex);
    if (!WhiteList.Contains(history))
    {
        WhiteList.Add(history.Key, history.Value);
        await power.InvokeAsync();
    }
    break;

每次只有两个位发生变化（BUILDING 和 部门设置）。所以，让我们把它拉到它自己的辅助函数中：

private async Task CheckWhiteList(PowerShell power)
{
    switch ((Building)Model.BuildingSelectedIndex)
    {
        case Building.CaneRidge:
            await InvokeScriptIfNotYetWhiteListedAsync(power, Model.UserID, (CaneRidgeSettings.Departments)Model.DepartmentSelectedIndex);
            break;

        case Building.Carothers:
            await InvokeScriptIfNotYetWhiteListedAsync(power, Model.UserID, (CarothersSettings.Departments)Model.DepartmentSelectedIndex);
            break;

        case Building.CSC:
            await InvokeScriptIfNotYetWhiteListedAsync(power, Model.UserID, (CSCSettings.Departments)Model.DepartmentSelectedIndex);
            break;

        case Building.HQ:
            await InvokeScriptIfNotYetWhiteListedAsync(power, Model.UserID, (HQSettings.Departments)Model.DepartmentSelectedIndex);
            break;

        default:
            break;
    }
}

private async Task InvokeScriptIfNotYetWhiteListedAsync(PowerShell power, string userID, Enum department)
{
    var history = new KeyValuePair<string, Enum>(userID, department);
    if (!WhiteList.Contains(userID))
    {
        WhiteList.Add(history.Key, history.Value)
        await power.InvokeAsync()
    }
}

但仍有重复的代码。如果我们取消对InvokeScriptIfNotYetWhiteListedAsync() 的呼叫会怎样？

我还在帮助函数中看到我们正在创建一个KeyValuePair 只是为了调用.Contains()。我们可以改用.ContainsKey() 来完全避免创建KeyValuePair 对象。

private async Task CheckWhiteList(PowerShell power)
{
    Enum department;
    switch ((Building)Model.BuildingSelectedIndex)
    {
        case Building.CaneRidge:
            department = (CaneRidgeSettings.Departments)Model.DepartmentSelectedIndex;
            break;

        case Building.Carothers:
            department = (CarothersSettings.Departments)Model.DepartmentSelectedIndex;
            break;

        case Building.CSC:
            department = (CSCSettings.Departments)Model.DepartmentSelectedIndex;
            break;

        case Building.HQ:
            department = (HQSettings.Departments)Model.DepartmentSelectedIndex;
            break;

        default:
            return;
    }

    await InvokeScriptIfNotYetWhiteListedAsync(power, Model.UserID, department);
}

private async Task InvokeScriptIfNotYetWhiteListedAsync(PowerShell power, string userID, Enum department)
{
    // I find compound conditionals sometimes are easier to read if they're
    // given a name before being used.
    var alreadyWhiteListed = WhiteList.ContainsKey(userID) && WhiteList[userID] == department;
    if (!alreadyWhiteListed)
    {
        WhiteList.Add(userID, department)
        await power.InvokeAsync()
    }
}

现在 switch 语句只是选择了正确的 Enum 值，我们也可以把它拉到一个帮助器中并给它一个好名字：

private async Task CheckWhiteList(PowerShell power)
{
    Enum department = GetDepartmentEnumForBuilding((Building)Model.BuildingSelectedIndex);
    await InvokeScriptIfNotYetWhiteListedAsync(power, Model.UserID, department);
}

private Enum GetDepartmentEnumForBuilding(Building building)
{
    switch (building)
    {
        case Building.CaneRidge:
            return (CaneRidgeSettings.Departments)Model.DepartmentSelectedIndex;

        case Building.Carothers:
            return (CarothersSettings.Departments)Model.DepartmentSelectedIndex;

        case Building.CSC:
            return (CSCSettings.Departments)Model.DepartmentSelectedIndex;

        case Building.HQ:
            return (HQSettings.Departments)Model.DepartmentSelectedIndex;

        default:
            throw new ArgumentOutOfRangeException(nameof(building));
    }
}

private async Task InvokeScriptIfNotYetWhiteListedAsync(PowerShell power, string userID, Enum department)
{
    var alreadyWhiteListed = WhiteList.ContainsKey(userID) && WhiteList[userID] == department;
    if (!alreadyWhiteListed)
    {
        WhiteList.Add(userID, department)
        await power.InvokeAsync()
    }
}

现在似乎没有太多重复的代码，每个函数做的工作也更少，所以可能更容易理解。

如果我们不想使用 Enum，我们还可以进行其他重构，但这可能已经足够了。

Answer 2

试一试：

public static Dictionary<Building, Func<int, Enum>> mySwitch = new Dictionary<Building, Func<int, Enum>>()
{
    { Building.CaneRidge, n => (CaneRidgeSettings.Departments)n },
    { Building.Carothers, n => (CarothersSettings.Departments)n },
    { Building.CSC, n => (CSCSettings.Departments)n },
    { Building.HQ, n => (HQSettings.Departments)n },
};

private async Task CheckWhiteList(PowerShell power)
{
    var history = new KeyValuePair<string, Enum>(Model.UserID, mySwitch[(Building)Model.BuildingSelectedIndex](Model.DepartmentSelectedIndex));
    if (!WhiteList.Contains(history))
    {
        WhiteList.Add(history.Key, history.Value);
        await power.InvokeAsync();
    }
}

如果它对你有用，请告诉我，我可以再解释一下。不过我现在得跑了。