如何简化或减少C#中的代码？

我正在用C#开发一个windows窗体应用程序，我是这方面的新手哈哈。 所以，我有这个代码，它工作得很好，但它有很多代码：/，我想简化或减少它。。。 这是我的代码，是关于小时的比较，例如：

开始日期：20:30

结束日期：21:00

现在日期时间：20:33

所以结果会是真的，但我需要做很多比较，我有很多假设，我如何减少它

public int verifyHour()
        {
            string hourMinute = DateTime.Now.ToString("HH:mm:ss");
            bool h1 = IsTimeOfDayBetween(Convert.ToDateTime(hourMinute), new TimeSpan(20, 25, 0), new TimeSpan(20, 30, 0));
            if(h1 == true)
            {
                return 1;
            }
            bool h2 = IsTimeOfDayBetween(Convert.ToDateTime(hourMinute), new TimeSpan(8, 00, 0), new TimeSpan(9, 00, 0));
            if (h2 == true)
            {
                return 2;
            }
            bool h3 = IsTimeOfDayBetween(Convert.ToDateTime(hourMinute), new TimeSpan(9, 00, 0), new TimeSpan(10, 00, 0));
            if (h3 == true)
            {
                return 3;
            }

            bool h4 = IsTimeOfDayBetween(Convert.ToDateTime(hourMinute), new TimeSpan(11, 00, 0), new TimeSpan(12, 00, 0));
            if (h4 == true)
            {
                return 4;
            }

            bool h5 = IsTimeOfDayBetween(Convert.ToDateTime(hourMinute), new TimeSpan(12, 00, 0), new TimeSpan(13, 00, 0));
            if (h5 == true)
            {
                return 5;
            }
            bool h6 = IsTimeOfDayBetween(Convert.ToDateTime(hourMinute), new TimeSpan(13, 00, 0), new TimeSpan(14, 00, 0));
            if (h6 == true)
            {
                return 6;
            }
            bool h7 = IsTimeOfDayBetween(Convert.ToDateTime(hourMinute), new TimeSpan(14, 00, 0), new TimeSpan(15, 00, 0));
            if (h7 == true)
            {
                return 7;
            }
            bool h8 = IsTimeOfDayBetween(Convert.ToDateTime(hourMinute), new TimeSpan(15, 00, 0), new TimeSpan(16, 00, 0));
            if (h8 == true)
            {
                return 8;
            }
            bool h9 = IsTimeOfDayBetween(Convert.ToDateTime(hourMinute), new TimeSpan(16, 00, 0), new TimeSpan(17, 00, 0));
            if (h9 == true)
            {
                return 9;
            }
            bool h10 = IsTimeOfDayBetween(Convert.ToDateTime(hourMinute), new TimeSpan(16, 00, 0), new TimeSpan(17, 00, 0));
            if (h10 == true)
            {
                return 10;
            }
            bool h11 = IsTimeOfDayBetween(Convert.ToDateTime(hourMinute), new TimeSpan(17, 00, 0), new TimeSpan(18, 00, 0));
            if (h11 == true)
            {
                return 11;
            }
            bool h12 = IsTimeOfDayBetween(Convert.ToDateTime(hourMinute), new TimeSpan(18, 00, 0), new TimeSpan(19, 00, 0));
            if (h12 == true)
            {
                return 12;
            }
            else
            {
                return -1;
            }
        }

---

这是对您所写内容的简化，尽管可能是错误的，因为您的h4没有在10:00~11:00（继续）进行检查，并且您在16:00~17:00进行了双重检查，这使得您永远无法返回10

public int verifyHour(DateTime datetime)
{
   if(datetime.Hour == 20 && datetime.Minute >= 25 && datetime.Minute <= 30)
   {
       return 1;
   }
   else(datetime.Hour <= 8 && datetime.Hour <= 18)
   {
       return datetime.Hour - 6;
   }
   return -1;
}

public int-verifyHour（DateTime-DateTime）
{
如果（datetime.Hour==20&&datetime.Minute>=25&&datetime.Minute这是对您所写内容的简化，尽管它可能是错误的，因为您的h4没有在10:00~11:00（并继续）进行检查，并且您在16:00~17:00进行了双重检查，这使得您永远无法返回10

public int verifyHour(DateTime datetime)
{
   if(datetime.Hour == 20 && datetime.Minute >= 25 && datetime.Minute <= 30)
   {
       return 1;
   }
   else(datetime.Hour <= 8 && datetime.Hour <= 18)
   {
       return datetime.Hour - 6;
   }
   return -1;
}

public int-verifyHour（DateTime-DateTime）
{
如果（datetime.Hour==20&&datetime.Minute>=25&&datetime.MinuteA（过于简化）的建议是：

如果您只是将小时数与秒数进行比较，只需执行以下操作：

public static int GetSeconds(DateTime dateTime) {
    return (dateTime.Hour * 3600) + (dateTime.Minutes * 60) + dateTime.Seconds;
}

public bool IsBetween(DateTime target, DateTime start, DateTime end) {
    var targetSeconds = GetSeconds(target);
    var startSeconds = GetSeconds(start);
    var endSeconds = GetSeconds(end);

    return startSeconds <= targetSeconds && endSeconds >= targetSeconds;
}

public static int GetMinutes(DateTime dateTime) {
    return (dateTime.Hour * 60) + dateTime.Minutes
}

public bool IsBetween(DateTime target, DateTime start, DateTime end) {
    var targetMinutes = GetMinutes(target);
    var startMinutes = GetMinutes(start);
    var endMinutes = GetMinutes(end);

    return startMinutes <= targetMinutes && endMinutes >= targetMinutes ;
}

publicstaticintgetseconds（DateTime-DateTime）{
return（dateTime.Hour*3600）+（dateTime.Minutes*60）+dateTime.Seconds；
}
公共bool IsBetween（日期时间目标、日期时间开始、日期时间结束）{
var targetSeconds=GetSeconds（目标）；
var startSeconds=GetSeconds（开始）；
var endSeconds=GetSeconds（结束）；
返回开始秒=目标秒；
}

如果你只是将小时与分钟进行比较，只需执行以下操作：

public static int GetSeconds(DateTime dateTime) {
    return (dateTime.Hour * 3600) + (dateTime.Minutes * 60) + dateTime.Seconds;
}

public bool IsBetween(DateTime target, DateTime start, DateTime end) {
    var targetSeconds = GetSeconds(target);
    var startSeconds = GetSeconds(start);
    var endSeconds = GetSeconds(end);

    return startSeconds <= targetSeconds && endSeconds >= targetSeconds;
}

public static int GetMinutes(DateTime dateTime) {
    return (dateTime.Hour * 60) + dateTime.Minutes
}

public bool IsBetween(DateTime target, DateTime start, DateTime end) {
    var targetMinutes = GetMinutes(target);
    var startMinutes = GetMinutes(start);
    var endMinutes = GetMinutes(end);

    return startMinutes <= targetMinutes && endMinutes >= targetMinutes ;
}

publicstaticintgetminutes（DateTime-DateTime）{
return（dateTime.Hour*60）+dateTime.Minutes
}
公共bool IsBetween（日期时间目标、日期时间开始、日期时间结束）{
var targetMinutes=GetMinutes（目标）；
var startMinutes=GetMinutes（开始）；
var endMinutes=GetMinutes（结束）；
返回开始分钟=目标分钟；
}
A（过于简化）的建议是：

如果您只是将小时数与秒数进行比较，只需执行以下操作：

public static int GetSeconds(DateTime dateTime) {
    return (dateTime.Hour * 3600) + (dateTime.Minutes * 60) + dateTime.Seconds;
}

public bool IsBetween(DateTime target, DateTime start, DateTime end) {
    var targetSeconds = GetSeconds(target);
    var startSeconds = GetSeconds(start);
    var endSeconds = GetSeconds(end);

    return startSeconds <= targetSeconds && endSeconds >= targetSeconds;
}

public static int GetMinutes(DateTime dateTime) {
    return (dateTime.Hour * 60) + dateTime.Minutes
}

public bool IsBetween(DateTime target, DateTime start, DateTime end) {
    var targetMinutes = GetMinutes(target);
    var startMinutes = GetMinutes(start);
    var endMinutes = GetMinutes(end);

    return startMinutes <= targetMinutes && endMinutes >= targetMinutes ;
}

publicstaticintgetseconds（DateTime-DateTime）{
return（dateTime.Hour*3600）+（dateTime.Minutes*60）+dateTime.Seconds；
}
公共bool IsBetween（日期时间目标、日期时间开始、日期时间结束）{
var targetSeconds=GetSeconds（目标）；
var startSeconds=GetSeconds（开始）；
var endSeconds=GetSeconds（结束）；
返回开始秒=目标秒；
}

如果你只是将小时与分钟进行比较，只需执行以下操作：

public static int GetSeconds(DateTime dateTime) {
    return (dateTime.Hour * 3600) + (dateTime.Minutes * 60) + dateTime.Seconds;
}

public bool IsBetween(DateTime target, DateTime start, DateTime end) {
    var targetSeconds = GetSeconds(target);
    var startSeconds = GetSeconds(start);
    var endSeconds = GetSeconds(end);

    return startSeconds <= targetSeconds && endSeconds >= targetSeconds;
}

public static int GetMinutes(DateTime dateTime) {
    return (dateTime.Hour * 60) + dateTime.Minutes
}

public bool IsBetween(DateTime target, DateTime start, DateTime end) {
    var targetMinutes = GetMinutes(target);
    var startMinutes = GetMinutes(start);
    var endMinutes = GetMinutes(end);

    return startMinutes <= targetMinutes && endMinutes >= targetMinutes ;
}

publicstaticintgetminutes（DateTime-DateTime）{
return（dateTime.Hour*60）+dateTime.Minutes
}
公共bool IsBetween（日期时间目标、日期时间开始、日期时间结束）{
var targetMinutes=GetMinutes（目标）；
var startMinutes=GetMinutes（开始）；
var endMinutes=GetMinutes（结束）；
返回开始分钟=目标分钟；
}
如果最初的问题是关于如何确定某个时间是否介于2次之间，那么您应该如何编码：

public bool IsInBetween(DateTime target, DateTime start, DateTime end)
{
    return start <= target && target <= end;
}

public bool在两者之间（日期时间目标、日期时间开始、日期时间结束）
{
return start如果最初的问题是关于如何确定某个时间是否介于2次之间，那么您应该如何编码：

public bool IsInBetween(DateTime target, DateTime start, DateTime end)
{
    return start <= target && target <= end;
}

public bool在两者之间（日期时间目标、日期时间开始、日期时间结束）
{
return start我假设您希望返回与当前时间不同的值，因为您将8AM设置为2。在编程中，您似乎一直使用的情况是a。因此，您可以使用switch语句将代码设置为这样

public int verifyHour()
{
    int hour = DateTime.Now.Hour;
    switch(hour) 
    {
        case 8:
            return 1;
            break; // not really necessary because you are returning but you should put these in for practice
       case 9:
            return 2;
            break;
       ... // so on for the rest of your cases
       default:  
            return -1;
            break;
    }
}

一旦你到了那里，你可能可以通过思考你正在接受什么输入和返回什么来进一步清理它，只需对return语句进行数学运算，将当前时间更改为你想要的值。
我假设你想要返回不同于当前时间的值，因为你将8AM设置为2。在programmi中你似乎已经改变的情况是一个。所以你可以使用switch语句像这样设置你的代码

public int verifyHour()
{
    int hour = DateTime.Now.Hour;
    switch(hour) 
    {
        case 8:
            return 1;
            break; // not really necessary because you are returning but you should put these in for practice
       case 9:
            return 2;
            break;
       ... // so on for the rest of your cases
       default:  
            return -1;
            break;
    }
}

一旦你到达那里，你可能会进一步清理它，考虑你正在接受什么输入和你正在返回什么，然后简单地对return语句进行数学运算，将当前时间更改为你想要的值。
我不清楚OP函数的确切用途，但是如果使用循环f，你可以大大减少它或者中间部分。请注意，我编写此函数是为了准确返回OP函数返回的内容：

public int verifyHour()
{
    Datetime nowConverted = Convert.ToDateTime(DateTime.Now.ToString("HH:mm:ss"));
    if (IsTimeOfDayBetween(nowConverted, new TimeSpan(20, 25, 0), new TimeSpan(20, 30, 0)))
    {
        return 1;
    }
    for(int i = 2, time = 8; i <= 12; ++i, ++time)
    {
        if (IsTimeOfDayBetween(nowConverted, new TimeSpan(time, 00, 0), new TimeSpan(time + 1, 00, 0))
        {
            return i;
        }
        else if (time == 9) //You don't compare between 10 and 11
        {
            ++time;
        }
        else if (time == 16) //You repeat this twice, so 10 will never be returned
        {
            ++i;
        }
    }
    return -1;
}

public int verifyHour（）
{
Datetime nowConverted=Convert.ToDateTime（Datetime.Now.ToString（“HH:mm:ss”）；
if（IsTimeOfDayBetween（现在已转换、新时间跨度（20,25,0）、新时间跨度（20,30,0）））
{
返回1；
}
对于（int i=2，time=8；i我不清楚OP函数的确切用途，但如果在中间部分使用循环，则可以将其减少很多。请注意，我编写此函数是为了精确返回OP函数返回的内容：

public int verifyHour()
{
    Datetime nowConverted = Convert.ToDateTime(DateTime.Now.ToString("HH:mm:ss"));
    if (IsTimeOfDayBetween(nowConverted, new TimeSpan(20, 25, 0), new TimeSpan(20, 30, 0)))
    {
        return 1;
    }
    for(int i = 2, time = 8; i <= 12; ++i, ++time)
    {
        if (IsTimeOfDayBetween(nowConverted, new TimeSpan(time, 00, 0), new TimeSpan(time + 1, 00, 0))
        {
            return i;
        }
        else if (time == 9) //You don't compare between 10 and 11
        {
            ++time;
        }
        else if (time == 16) //You repeat this twice, so 10 will never be returned
        {
            ++i;
        }
    }
    return -1;
}

public int verifyHour（）
{
Datetime nowConverted=Convert.ToDateTime（Datetime.Now.ToString（“HH:mm:ss”）；
if（IsTimeOfDayBetween（现在已转换、新时间跨度（20,25,0）、新时间跨度（20,30,0）））
{
返回1；
}
对于（int i=2，time=8；我建议您将此问题发布到codereview.stackexchange.com，因为堆栈溢出不是一个审查平台。我认为切换案例将是一个更好的选择。嗯，我也认为在切换案例中，但我不知道如何实现这一点，因为我需要将实际的时分与开始时分时间进行比较，最后一小时一分钟的时间…我投票结束这个问题，因为它属于codereview，而不是SO。每当你有大量复制和粘贴代码时，是时候创建数组了。我建议你将这个问题发布到codereview.stackexchange.com，因为Stack Ov