C# 如何根据一天中的时间生成一个随机数？

我正在Azure Iot hub中模拟一个Iot设备（噪声传感器），下面的代码工作得非常好。 然而，我想模拟一些更接近现实的东西，在不同的时间里，我可以使用不同的分贝范围

大概是这样的：

if 00.00- 7.00AM - Randum number between (10-20)
if 7am-9AM - Random number  between (20-40)
if 11.30-1.30pm Random number between 60-80

我不想创建大量的IFs，else，因为我希望有更干净的代码

我应该如何以结构化的方式进行此操作

我的代码如下：（仅适用于相关方法）

专用静态异步任务SendDeviceToCloudMessagesAsync（CancellationToken ct）
{
//初始遥测值
int-minNoise=20；
int maxNoise=90；
var rand=new Random（）；
而（！ct.iscancellationrequest）
{
double noiseDecibels=rand.Next（minNoise，maxNoise）；
//创建JSON消息
字符串messageBody=JsonSerializer.Serialize(
新的
{
eui=“58A0CB0000101DB6”，
分贝值=噪音分贝
});
使用var message=新消息（Encoding.ASCII.GetBytes（messageBody））
{
ContentType=“application/json”，
ContentEncoding=“utf-8”，
};
//向消息中添加自定义应用程序属性。
//物联网中心可以在这些属性上进行过滤，而无需
//访问消息正文。
message.Properties.Add（“noiseAlert”，（noiseDecibels>70）？“true”：“false”）；
//发送遥测信息
等待s_deviceClient.SendEventAsync（消息）；
WriteLine（$“{DateTime.Now}>发送消息：{messageBody}”）；
等待任务。延迟（60000）；
}
}

如果您有这样的特定条件，唯一的方法是手动检查哪种条件适用

private Random randomGenerator = new Random();



function decibel(DateTime d) {
  int randMin = 0, randMax = 0; //the interval for the random value
  var t = d.TimeOfDay;

  if (t.TotalHours < 7)  //0:00 - 6:59:59 
  {
    randMin = 10; randMax = 20;
  }
  else if (d.TotalHours < 9)  //7:00 - 8:59:59 
  {
    randMin = 20; randMax = 40;
  }
  else if (d.TotalHours >= 11.5 && d.TotalHours < 13.5) //11:30 - 13:29:59
  {
    randMin = 60; randMax = 80;
  }
  ...


  // returns a rand with:  randMin <= rand < randMax
  return randomGenerator.Next(randMin, randMax);
}

private Random Random generator=new Random（）；
函数分贝（日期时间d）{
int randMin=0，randMax=0；//随机值的间隔
var t=d.一天的时间；
如果（t.TotalHours<7）//0:00-6:59:59
{
randMin=10；randMax=20；
}
否则如果（d.TotalHours<9）//7:00-8:59:59
{
randMin=20；randMax=40；
}
否则如果（d.TotalHours>=11.5&&d.TotalHours<13.5）//11:30-13:29:59
{
randMin=60；randMax=80；
}
...
//返回一个带有：randMin的rand，我正在以数据结构模式（如您所问）处理这个问题，因此我将创建一个从Dictionary继承的RangeHourDictionary类

Add
方法将添加范围，其中键表示开始时间和结束时间。值将是一个大小为2的int数组，其中第一个值表示开始范围，第二个值表示范围的结束

另一个函数是
GetRandomRange
，它将获取当前时间并返回值（同样，它将表示随机范围的开始和结束）

公共类范围字典：字典
{
public void Add（TimeSpan-from、TimeSpan-to、int[]随机值）
{
添加（新范围（从、到）、随机值）；
}
public int[]GetRandomRange（TimeSpan now）
{
尝试
{
返回此.First（x=>x.Key.Fromnow）.Value；
}
抓住
{
返回null；
}
}
}
公共结构范围
{
公共范围（时间跨度从，时间跨度到）：this（）
{
From=From；
To=To；
}
来自{get；}的公共时间跨度
到{get；}的公共时间跨度
}
//初始化
var lookup=newrangedictionary（）；
Add（newtimespan（07,0,0），newtimespan（09,0,0），newint[2]{10,20}）；
Add（newtimespan（09,30,0），newtimespan（11,0,0），newint[2]{40,50}）；
Add（新的时间跨度（11,0,0），新的时间跨度（13,0,0），新的int[2]{60,80}）；
//调用GetRandomRange
var res=lookup.GetRandomRange（DateTime.Now.TimeOfDay）；
如果（res！=null）{
随机=新随机（）；
var randomValue=random.Next（res[0]，res[1]）；
}
如果您想要具有特定标准的内容，则必须使用If/else语句来满足该标准，但没有其他方法。遗憾的是，您可以创建一个函数，根据时间返回分贝值，这将有助于保持分贝值“更干净”
public class RangeDictionary : Dictionary<Range, int[]>
{
   public void Add(TimeSpan from, TimeSpan to, int[] randomValues)
   {
      Add(new Range(from, to), randomValues);
   }

   public int[] GetRandomRange(TimeSpan now)
   {
       try
       {
            return this.First(x => x.Key.From < now && x.Key.To > now).Value;
       }
       catch
       {
            return null;
       }
    }
}

public struct Range
{
     public Range(TimeSpan from, TimeSpan to) : this()
     {
          From = from;
          To = to;
      }
      public TimeSpan From { get; }
      public TimeSpan To { get; }
 }


//initialize

 var lookup = new RangeDictionary();
 lookup.Add(new TimeSpan(07, 0, 0), new TimeSpan(09, 0, 0), new int[2] { 10, 20 });
 lookup.Add(new TimeSpan(09, 30, 0), new TimeSpan(11, 0, 0), new int[2] { 40, 50 });
 lookup.Add(new TimeSpan(11, 0, 0), new TimeSpan(13, 0, 0), new int[2] { 60, 80 });


// call GetRandomRange

 var res = lookup.GetRandomRange(DateTime.Now.TimeOfDay);
 if (res != null){
    Random random = new Random();
    var randomValue = random.Next(res[0], res[1]);
 }