C# 按时间间隔验证时间

我有三条规则：

• A.上午9点到下午3点之间的时段
• B.下午3点到7点之间的时段
• C.晚上7点到上午9点之间的时段

目前我将它们表示为

TimeSpan

s

public class Rule
{
    public string Name {get; set;}
    public TimeSpan From {get; set;}
}

List<Rule> rules = new List<Rule>()
{
   new Rule() {From = new TimeSpan(9, 0, 0), Name = "A"},
   new Rule() {From = new TimeSpan(15, 0, 0), Name = "B"},
   new Rule() {From = new TimeSpan(19, 0, 0), Name = "C"}
};

公共类规则
{
公共字符串名称{get；set；}
从{get；set；}开始的公共时间跨度
}
列表规则=新列表（）
{
新规则（）{From=newtimespan（9,0,0），Name=“A”}，
new Rule（）{From=new TimeSpan（15,0,0），Name=“B”}，
新规则（）{From=newtimespan（19,0,0），Name=“C”}
};

我的问题是如何验证时间输入，比如说9点10分，是否符合该规则

---

它应该选择第三条规则。

您可以使用以下规则：

DateTime input = DateTime.Now;

TimeSpan span = input.TimeOfDay;
for (int i = 0; i < rules.Count - 1; i++) {
    if (span >= rules[i].From && span < rules[i + 1].From) {
        return rules[i];
    }
}
return rules[rules.Count - 1];

DateTime输入=DateTime.Now；
TimeSpan=input.TimeOfDay；
for（int i=0；i=规则[i]。From&&span

下面类似的内容可能会起作用：

var currentSpan = DateTime.Now - DateTime.Now.Date;
int ruleIndex = -1;

for (int i = 0; i < rules.Count - 1; i++)
{
    if (currentSpan >= rules[i].From && currentSpan < rules[i + 1].From)
    {
        ruleIndex = i;
        break;
    }
}

if (ruleIndex == -1 && (currentSpan >= rules.Last().From || currentSpan < rules.First().From))
{
    ruleIndex = rules.Count - 1;
}

var rule = rules[ruleIndex];

var currentSpan=DateTime.Now-DateTime.Now.Date；
int ruleIndex=-1；
for（int i=0；i=规则[i]。From&¤tSpan=rules.Last（）.From | | currentSpan

一天只有24小时。您是否可以为分配创建一个带有枚举的映射数组：

public enum Category
{
 A,
 B,
 C
}

然后是数组。所以从你的分类来看，00:00-09:00应该是C

Category[] values = new Category[24];
for(int i = 0;i<9;i++)
{
 values[i] = Category.C;
}

---

通过向

规则

对象添加结束时间进行轻微修改

public class Rule {
    public string Name { get; set; }
    public TimeSpan From { get; set; }
    public TimeSpan To { get; set; }
}

此扩展方法用于检查提供的输入是否在规则的时间范围内

public static class RuleExtension {
    public static bool Contains(this Rule rule, TimeSpan input) {
        var value = TimeSpan.Parse(input.ToString());
        var start = rule.From;
        var end = rule.To;

        if (end < start) {
            //loopback
            end += TimeSpan.FromHours(24);
            if (value < start)
                value += TimeSpan.FromHours(24);
        }

        return start.CompareTo(value) <= 0 && value.CompareTo(end) < 0;
    }
}

公共静态类规则扩展{
公共静态bool包含（此规则，TimeSpan输入）{
var value=TimeSpan.Parse（input.ToString（））；
var start=rule.From；
var end=rule.To；
如果（结束<开始）{
//环回
结束+=从小时开始的时间跨度（24）；
如果（值<开始）
值+=时间跨度从小时（24）；
}
返回start.CompareTo（值）r.Contains（输入））
.Should（）
.NotBeNull（）
.及
.Match（（规则r）=>r.Name==“C”）；
输入=TimeSpan.Parse（“08:10”）；
rules.FirstOrDefault（r=>r.Contains（输入））
.Should（）
.BeNull（）；
输入=TimeSpan.Parse（“18:10”）；
rules.FirstOrDefault（r=>r.Contains（输入））
.Should（）
.NotBeNull（）
.及
.Match（（规则r）=>r.Name==“B”）；
输入=TimeSpan.Parse（“10:10”）；
rules.FirstOrDefault（r=>r.Contains（输入））
.Should（）
.NotBeNull（）
.及
.Match（（规则r）=>r.Name==“A”）；
}

你有一个问题，你的时间跨度重叠。上午9点在a和C区，下午3点在a和B区，晚上7点在B和C区。凯文推测开始是包含的，结束是独占的。好吧，我可以将时间跨度添加到，所以如果你想要当前时间，你可以只做

DateTime。现在。TimeOfDay

@juharr，thanks，我已经在msitt的回答中注意到了。如果我输入var current=新时间跨度（20，0，0）；或var current=新时间跨度（6，0，0）；@Andrei，让我试着运行它看看。它不适合从午夜开始切换。@Andrei这是我对这个主题的输入。谢谢

public static class RuleExtension {
    public static bool Contains(this Rule rule, TimeSpan input) {
        var value = TimeSpan.Parse(input.ToString());
        var start = rule.From;
        var end = rule.To;

        if (end < start) {
            //loopback
            end += TimeSpan.FromHours(24);
            if (value < start)
                value += TimeSpan.FromHours(24);
        }

        return start.CompareTo(value) <= 0 && value.CompareTo(end) < 0;
    }
}

[TestClass]
public class MyTestClass {
    [TestMethod]
    public void _ValidateTime() {
        var rules = new List<Rule>()
        {
           new Rule() {From = new TimeSpan(9, 0, 0), To = new TimeSpan(15, 0, 0), Name = "A"},
           new Rule() {From = new TimeSpan(15, 0, 0), To = new TimeSpan(19, 0, 0), Name = "B"},
           new Rule() {From = new TimeSpan(19, 0, 0), To= new TimeSpan(5, 0, 0), Name = "C"}
        };

        var input = TimeSpan.Parse("21:10");
        rules.FirstOrDefault(r => r.Contains(input))
            .Should()
            .NotBeNull()
            .And
            .Match((Rule r) => r.Name == "C");

        input = TimeSpan.Parse("08:10");
        rules.FirstOrDefault(r => r.Contains(input))
            .Should()
            .BeNull();

        input = TimeSpan.Parse("18:10");
        rules.FirstOrDefault(r => r.Contains(input))
            .Should()
            .NotBeNull()
            .And
            .Match((Rule r) => r.Name == "B");

        input = TimeSpan.Parse("10:10");
        rules.FirstOrDefault(r => r.Contains(input))
            .Should()
            .NotBeNull()
            .And
            .Match((Rule r) => r.Name == "A");
    }