Question

我有网站执行匹配操作。我正在编写代码来限制基于当前匹配阶段的一些操作。例如，如果前半部分是当前阶段，那么我应该限制直接结束比赛，而不是后半部分。对于每个阶段，我有多个限制阶段。以下是我的舞台枚举。

public enum MatchStage
    {
        FirstHalfAssumedStartTime = 1,
        FirstHalfAssumedEndTime = 2,
        SecondHalfAssumedStartTime = 3,
        SecondHalfAssumedEndTime = 4,
        ExtraFirstHalfAssumedStartTime = 5,
        ExtraFirstHalfAssumedEndTime = 6,
        ExtraSecondHalfAssumedStartTime = 7,
        ExtraSecondHalfAssumedEndTime = 8,
        PauseStartTime = 9,
        PauseEndTime = 10,
        EndMatchTime = 11
    }

我想在下面的方法工作。我想调用类似 currentSiteCoreStage.RestrictedStages 的东西，它返回受限制阶段的列表。我怎样才能做到这一点？

public static bool IsProposedStageValid(MatchStage currentSiteCoreStage, MatchStage proposedStage )
        {
            if (currentSiteCoreStage.RestrictedStages.Contains(proposedStage)) // I am hoping to make this work
                return false;
        }

Answer 1

这里有你的实际状态机。您可以创建方法，为应用程序支持的每个阶段定义可能的阶段转换。例如。（当然你不必使用迭代器，你只需返回每个case块的阶段数组）：

public static IEnumerable<MatchStage> GetAvailableStageTransitions(MatchStage stage)
{
    switch (stage)
    {
        case MatchStage.FirstHalfAssumedStartTime:
            yield return MatchStage.FirstHalfAssumedEndTime;
            yield return MatchStage.PauseStartTime;
            yield break;
        case MatchStage.SecondHalfAssumedStartTime:
            yield return MatchStage.SecondHalfAssumedEndTime;
            yield return MatchStage.PauseStartTime;
            yield break;
        // etc
        default:
            throw new NotSupportedException($"Stage {stage} is not supported.");
    }
}

然后检查建议的阶段是否可用：

GetAvailableStageTransitions(currentSiteCoreStage).Contains(proposedStage)

根据系统的复杂程度，您可以考虑将状态转换和对每个状态实现的逻辑封装到状态对象中。有关详细信息，请参阅State Design Pattern。

Answer 2

也许考虑这样的事情： 1：你的枚举

2：

public class Stage
{
    public MatchStage MathStage { get; set; }
    public List<MatchStage> PossibleStages { get; set; }
}

3。

public static bool IsProposedStageValid(Stage currentSiteCoreStage, MatchStage proposedStage)
{
     if (currentSiteCoreStage.PossibleStages.Contains(proposedStage)) // I am hoping to make this work
     return false;

     return true;
}

示例：

Stage st1 = new Stage
{
      MathStage = MatchStage.FirstHalfAssumedStartTime,
      PossibleStages = new List<MatchStage> { MatchStage.FirstHalfAssumedEndTime }
};

bool res = IsProposedStageValid(st1, MatchStage.PauseEndTime);

Answer 3

一种方法是让一个类了解您当前的阶段，并根据当前阶段生成RestrictedStages。类似的东西：

public enum Stage
{
    First, Second, Third
}

public class CoreStage
{
    public Stage CurrentStage { get; private set; }

    public IEnumerable<Stage> RestrictedStages { get; private set; }

    public CoreStage(Stage currentStage)
    {
        CurrentStage = currentStage;
        RestrictedStages = GenerateRestrictedStages();
    }

    private IEnumerable<Stage> GenerateRestrictedStages()
    {
        //apply your logic to determine Restricted stages based on current stage.
        return null;
    }
}

现在，你的IsProposedStageValid方法看起来如下：

public static bool IsProposedStageValid(Stage currentSiteCoreStage, Stage proposedStage)
    {
        var coreStage = new CoreStage(currentSiteCoreStage);
        if (coreStage.RestrictedStages.Contains(proposedStage))
        {
            //do whatever you want.
        }
        return false;
    }

如何将列表与c＃

3 个答案: