ExpiresUtc = DateTime.UtcNow.AddDays(0)是什么意思

这里的`<ChargeLog>`是一个泛型参数，用于指定DeleteManyAsync方法需要删除的实体类型。具体来说，该参数指定了实体对应的MongoDB集合名称和BsonClassMap映射规则等信息。 根据你提供的代码片段来看，该参数并没有随着变量的改变而改变，而是始终指定为`ChargeLog`类型。如果你需要根据不同的实体类型来删除数据，可以将该泛型参数改为`Type`类型，然后在方法调用时传入具体的实体类型即可，例如： ```csharp Type entityType = typeof(ChargeLog); var DelJson = new { OnDate = new BsonDocument("$lt", DateTime.UtcNow.AddDays(-i)) }; var Delcount = await _mongodb.DeleteManyAsync("BackEnd", entityType, DelJson); ``` 在上述代码中，`DeleteManyAsync`方法的第一个参数指定了MongoDB集合名称，第二个参数指定了实体类型，第三个参数指定了删除条件。这样就可以根据不同的实体类型来删除数据了。

<think>根据提供的代码片段，问题描述是：如果夜班生产，白班没有生产，第二天又是夜班，这样TempCount不会清零。 代码逻辑是：通过比较当前班次（currentShift）和上一次的班次（lastShift）来判断是否切换班次。如果不同，则重置TempCount为0。 但是，问题描述的情况是：夜班生产（假设是NightShift）后，白班（DayShift）没有生产，然后第二天又是夜班（NightShift）。 在这种情况下，代码中如何记录lastShift和currentShift？ 分析代码： 1. 首先，代码中通过_data.LastUnloadUnit.Shift获取上一次的班次（lastShift），然后根据当前时间计算当前班次（currentShift）。 2. 然后比较currentShift和lastShift，如果不相等，则重置TempCount。 问题在于：当白班没有生产时，可能不会更新_data.LastUnloadUnit.Shift（即lastShift仍然是上一次夜班的NightShift）。 而第二天夜班开始时，当前班次（currentShift）是NightShift，而lastShift也是NightShift（因为白班没有生产，没有更新lastShift）， 因此不会触发班次切换，不会重置TempCount。 所以，我们需要在每天切换班次的时候，即使没有生产，也应该更新班次信息？或者，我们需要在每天开始的时候重置TempCount？ 但是，原逻辑是：只有当班次发生变化时才重置。而问题中描述的情况，夜班->白班（没有生产，lastShift没有更新）->夜班，那么两个夜班之间没有班次变化（都是夜班），所以不会重置。 因此，我们需要修改逻辑：不仅仅是比较相邻两次的班次，还要考虑日期是否跨天？或者，我们不仅要判断班次，还要判断日期？ 另一种思路：重置TempCount的条件应该是每天第一次进入夜班（或白班）的时候，而不是相邻两次班次不同。也就是说，每个班次开始的时候，无论上一个班次是什么，都要重置。 但是，原需求可能是：在同一个班次内，TempCount持续累计，跨班次（即使跨天）则重置。问题中描述的情况，两个夜班属于不同的工作日，应该重置。 所以，我们需要在判断班次切换时，除了班次不同，还要考虑日期是否变化？或者，我们直接判断是否进入了一个新的班次（即使班次名称相同，但日期不同就算新的班次）？ 然而，原代码中并没有记录班次对应的日期。因此，我们可以修改为：在每次获取当前班次时，同时记录日期，然后比较当前班次的日期和上一次班次的日期，如果日期不同，则即使班次相同也重置？或者，我们重置的条件是：当前时间进入了一个新的班次时间段（即当前时间在某个班次内，而上一次记录的时间在另一个班次时间段，即使班次名称相同，但时间上已经跨过了另一个班次，那么就应该重置？） 但是，班次定义如下： - 早班（MorningShift）：8:00-20:00 - 夜班（NightShift）：20:00-次日8:00 注意：夜班是跨天的。所以，两个连续的夜班：第一个夜班是今天20:00到明天8:00，第二个夜班是明天20:00到后天8:00。它们之间有一个白天的间隔（白班：8:00-20:00）。 所以，在第二个夜班开始的时候（即明天20:00），我们期望重置TempCount。 如何判断？我们可以记录上一次生产时的班次和日期（注意：夜班跨天，所以夜班的日期应该算开始日期？还是结束日期？）。但是，问题在于白班没有生产，所以没有更新lastShift。 因此，我们需要一个独立于生产记录的班次跟踪机制。也就是说，即使没有生产，我们也应该知道当前班次和上一个班次是什么。 修改思路： 1. 我们不再依赖_data.LastUnloadUnit.Shift（因为它只在生产时更新），而是独立记录上一次的班次（lastShift）和对应的日期（或时间范围）。 2. 每次运行时，计算当前班次（currentShift）和当前班次的开始时间（我们可以根据当前时间计算出当前班次的开始时间）。 3. 然后，我们比较当前班次的开始时间和上一次记录的班次开始时间。如果当前班次的开始时间在上一次记录的班次结束时间之后（即中间有间隔），那么我们就认为班次已经切换，重置TempCount。 但是，这样需要记录上一次班次的结束时间，并且要持久化（因为程序可能重启）。 另一种简单思路：每次程序启动时（或者每天某个固定时间）重置？但这样也不准确。 考虑到问题描述，我们可能只需要在每次进入夜班或白班时，如果发现当前时间已经超过了上一次班次的结束时间，就重置。但是，这需要记录上一次班次的结束时间。 由于原代码片段中，lastShift是从_data.LastUnloadUnit.Shift获取的，而_data.LastUnloadUnit.Shift只在生产时更新，所以当没有生产时，它不会更新，导致lastShift停留在上一次生产的班次。 因此，我们需要改变lastShift的更新时机：即使没有生产，我们也要根据时间更新lastShift。但这样，我们就需要独立存储lastShift（不能只依赖生产记录）。 具体修改方案： 我们可以将lastShift和lastShiftEndTime（上一次班次的结束时间）保存到持久化存储（如文件、数据库或内存中，但要考虑重启）。 但是，由于问题描述中并没有说明运行环境，我们假设这是一个持续运行的服务。我们可以将lastShift和lastShiftEndTime作为类的成员变量，并在每次比较后更新。 步骤： 1. 定义两个新的变量：lastShift（记录上一次的班次）和lastShiftEndTime（记录上一次班次的结束时间）。 2. 在每次需要判断的时候（比如每次运行该逻辑时），计算当前班次（currentShift）和当前班次的开始时间（currentShiftStart）以及结束时间（currentShiftEnd）。 3. 比较当前时间（now）和lastShiftEndTime： 如果当前时间大于等于lastShiftEndTime，说明已经过了上一个班次，那么应该重置TempCount，并更新lastShift和lastShiftEndTime为当前班次的信息。 否则，不重置。 但是，这样每次都要重置？因为当前时间总是大于等于当前班次的开始时间，而当前班次的开始时间可能在上一个班次结束时间之后？不对，因为班次是连续的：夜班结束时间（次日8:00）和早班开始时间（次日8:00）是连续的，早班结束时间（次日20:00）和下一个夜班开始时间（次日20:00）也是连续的。 所以，我们需要判断的是：当前班次是否是一个新的班次（即当前班次的开始时间是否大于上一次记录班次的结束时间）。但是，由于班次是连续的，所以当前班次的开始时间等于上一次班次的结束时间（如果连续的话）。那么，什么情况下会有间隔？当上一个班次结束后，下一个班次没有立即开始（比如设备停机，没有生产，也没有记录班次），那么中间就会有一段间隔。 因此，重置的条件是：当前时间已经超过了上一次班次的结束时间，并且当前时间处于当前班次的时间段内。 具体步骤： 1. 初始化：记录上一次的班次（lastShift）和该班次的结束时间（lastShiftEndTime）。 2. 计算当前班次（currentShift）和当前班次的开始时间（currentShiftStart）和结束时间（currentShiftEnd）。 3. 如果当前时间（now）大于等于lastShiftEndTime，并且当前时间在currentShiftStart和currentShiftEnd之间，那么说明已经进入了一个新的班次（即使这个班次和上一次班次相同，但日期不同），重置TempCount，并更新lastShift为currentShift，lastShiftEndTime为currentShiftEnd。 4. 否则，不重置。 但是，这里有一个问题：在同一个班次内，每次运行该逻辑，只要当前时间大于lastShiftEndTime（即上一次记录的班次结束时间）就会重置，这显然不对。因为同一个班次内，我们只需要重置一次。 所以，我们需要确保每个班次只重置一次。我们可以记录当前班次的开始时间，如果这个开始时间已经被处理过，就不再重置。或者，我们更新lastShiftEndTime后，就不会再满足条件（因为lastShiftEndTime被更新为当前班次的结束时间，而当前时间小于这个结束时间，直到班次结束）。 但是，当班次切换时，条件会再次满足。 因此，修改后的逻辑： 我们维护两个状态：lastShift（上一次班次）和lastShiftEndTime（上一次班次的结束时间）。在每次运行时： 计算当前班次currentShift，以及当前班次的开始时间currentShiftStart和结束时间currentShiftEnd。 如果当前时间在currentShiftStart和currentShiftEnd之间： 如果当前时间 >= lastShiftEndTime（说明已经过了上一个班次的结束时间）： 重置TempCount 更新lastShift = currentShift 更新lastShiftEndTime = currentShiftEnd 否则，不重置（说明还在同一个班次内，且没有跨过班次结束时间） 注意：在同一个班次内，第一次运行该逻辑时，由于当前时间>=lastShiftEndTime（因为lastShiftEndTime是上一个班次的结束时间，而当前时间已经进入当前班次，所以一定大于等于上一个班次的结束时间），所以会重置，并更新lastShiftEndTime为当前班次的结束时间。然后，在同一个班次内再次运行时，由于lastShiftEndTime已经被更新为当前班次的结束时间（而当前时间小于这个结束时间），所以不会再次重置。 这样，在进入新的班次（无论是同一种班次还是不同班次）时，都会重置一次。 但是，这里有一个问题：如果程序在班次中间启动，那么lastShiftEndTime可能是很久以前的时间，那么当前时间一定大于lastShiftEndTime，所以会重置。这符合要求（因为可能跨了很多班次，所以需要重置）。 所以，我们需要持久化lastShift和lastShiftEndTime，以便在程序重启后仍然有效。 由于原代码中没有这些状态，我们需要添加。另外，原代码中lastShift是从_data.LastUnloadUnit.Shift获取的，我们将不再使用它，而是使用我们维护的lastShift。 修改后的代码结构： 定义两个类成员变量（并持久化，如果程序重启需要从存储中读取）： private Shift _lastShift; // 上一次的班次 private DateTime _lastShiftEndTime; // 上一次班次的结束时间 然后，在每次需要判断的地方（可能是每次生产前，或者定时执行），运行以下逻辑： DateTime now = DateTime.Now; // 计算当前班次currentShift，以及当前班次的开始时间currentShiftStart和结束时间currentShiftEnd (Shift currentShift, DateTime shiftStart, DateTime shiftEnd) = GetCurrentShiftInfo(now); // 如果当前时间在shiftStart和shiftEnd之间 if (now >= shiftStart && now <= shiftEnd) { // 检查是否已经进入新的班次（即当前时间超过了上一次班次的结束时间） if (now >= _lastShiftEndTime) { // 重置TempCount TempCount = 0; logger.Debug($"班次切换： {_lastShift} -> {currentShift}, TempCount 已重置为0"); // 更新状态 _lastShift = currentShift; _lastShiftEndTime = shiftEnd; } } 注意：在初始化时，我们需要设置_lastShift和_lastShiftEndTime。如果没有历史记录，我们可以根据当前时间计算一个初始值。 但是，还有一个问题：在同一个班次内，如果程序多次运行，第一次运行会重置，后面的运行不会重置，符合要求。 然而，在夜班（跨天）的情况下，如何计算shiftStart和shiftEnd？ 例如，当前时间是今天20:00，那么夜班的开始时间就是今天20:00，结束时间是明天8:00。 计算当前班次信息的函数GetCurrentShiftInfo可以这样实现： public (Shift shift, DateTime start, DateTime end) GetCurrentShiftInfo(DateTime now) { DateTime today = now.Date; DateTime morningShiftStart = today.AddHours(8); // 今天8:00 DateTime morningShiftEnd = today.AddHours(20); // 今天20:00 DateTime nightShiftStart = today.AddHours(20); // 今天20:00 DateTime nightShiftEnd = today.AddDays(1).AddHours(8); // 明天8:00 if (now >= morningShiftStart && now < morningShiftEnd) { return (Shift.MorningShift, morningShiftStart, morningShiftEnd); } else { // 夜班：注意跨天 return (Shift.NightShift, nightShiftStart, nightShiftEnd); } } 注意：这里我们假设班次划分是：早班 [8:00, 20:00)，夜班 [20:00, 次日8:00) 但是，原代码中班次的划分似乎有重叠？原代码中： 8:00-20:00是白班（DayShift）？而20:00-24:00和0:00-8:00是夜班（NightShift）？ 原代码中： if (n.Hour >= 20 && n.Hour <= 24) // 实际上，24时是0时，所以n.Hour>=20 && n.Hour<24? 但是n.Hour最大23，所以这里包括20,21,22,23 { StartTime = ... 20:00 EndTime = 次日8:00 } else if (n.Hour>=0 && n.Hour<8) // 0-7点 { StartTime = 前一天20:00 EndTime = 当天8:00 } 所以，班次划分是： 夜班：20:00（当天）到次日8:00 早班：8:00（当天）到20:00（当天） 因此，GetCurrentShiftInfo可以按照上述划分。 但是，原代码中班次名称是字符串：MorningShift（早班）和DayShift（白班）？但是后面的代码中又出现了Shift.DayShift和Shift.NightShift。这里需要统一。 根据原代码： case "MorningShift": lastShift = Shift.DayShift; // 这里似乎有误？？ 原代码中，当_data.LastUnloadUnit.Shift是"MorningShift"时，lastShift设置为DayShift？这可能是原代码的一个错误。 我们需要明确班次的定义： 原代码中，班次有三个枚举值？但是原代码中只出现了两个：MorningShift和DayShift？而后面又用到了Shift.DayShift和Shift.NightShift。 所以，这里可能混淆了。我们需要根据实际业务来确定班次。 假设班次只有两个：早班（MorningShift）和夜班（NightShift）？但是原代码中有一个case "DayShift"，所以可能还有白班（DayShift）？ 但是，原代码中计算时间段时，只分了两段：8:00-20:00和20:00-次日8:00。所以应该是两个班次：白天班（8:00-20:00）和夜班（20:00-次日8:00）。而白天班可能被称为MorningShift（早班）或者DayShift（白班）？这里原代码可能不一致。 为了清晰，我们重新定义班次枚举： public enum Shift { DayShift, // 白班：8:00-20:00 NightShift // 夜班：20:00-次日8:00 } 那么，原代码中从_data.LastUnloadUnit.Shift获取的字符串可能是"DayShift"或"NightShift"，但原代码中却出现了"MorningShift"和"DayShift"，这可能是历史遗留问题。 因此，我们需要调整：将字符串映射到枚举。 原代码中： switch (_data.LastUnloadUnit.Shift.ToString()) { case "MorningShift": lastShift = Shift.DayShift; // 这里将MorningShift映射为DayShift？为什么？ break; case "DayShift": lastShift = Shift.NightShift; break; } 这个映射很奇怪。可能原系统中，生产记录的班次名称是MorningShift和DayShift，而代码中定义的班次是DayShift和NightShift。并且，MorningShift对应的是DayShift（白班），而DayShift（生产记录中的）对应的是NightShift（夜班）？这可能是命名上的混淆。 因此，为了不修改原系统的生产记录，我们保留这个映射。但是，在新的逻辑中，我们统一使用DayShift和NightShift。 所以，在新的GetCurrentShiftInfo函数中，我们返回的班次是DayShift或NightShift。 修改后的完整代码示例： 注意：以下代码是C#，并且假设已经定义了Shift枚举。 首先，我们定义两个成员变量来存储上一次的班次和结束时间（需要持久化，这里假设使用文件或数据库存储，但为了简化，我们只作为类成员，实际中可能需要持久化机制）。 然后，我们实现GetCurrentShiftInfo函数。 最后，在需要判断的地方调用。 由于原代码片段不完整，我尝试重构： 我们创建一个类ShiftManager，用于管理班次状态。 代码如下： ```csharp public enum Shift { DayShift, // 8:00-20:00 NightShift // 20:00-次日8:00 } public class ShiftManager { private Shift _lastShift; private DateTime _lastShiftEndTime; private readonly ILogger _logger; public ShiftManager(ILogger logger) { _logger = logger; // 初始化：从持久化存储中加载_lastShift和_lastShiftEndTime // 这里为了简化，假设初始化为当前班次的前一个班次（以便第一次运行时会重置） // 实际中，应该从配置文件或数据库加载 DateTime now = DateTime.Now; var (currentShift, shiftStart, shiftEnd) = GetCurrentShiftInfo(now); // 设置_lastShift为当前班次的前一个班次（这样第一次运行就会重置） _lastShift = currentShift == Shift.DayShift ? Shift.NightShift : Shift.DayShift; // 设置_lastShiftEndTime为当前班次开始时间（这样now>=_lastShiftEndTime就会满足） _lastShiftEndTime = shiftStart; } public void CheckShiftReset(ref int tempCount) { DateTime now = DateTime.Now; var (currentShift, shiftStart, shiftEnd) = GetCurrentShiftInfo(now); // 确保当前时间在shiftStart和shiftEnd之间 if (now >= shiftStart && now <= shiftEnd) { // 检查是否已经进入新的班次（当前时间超过了上一次班次的结束时间） if (now >= _lastShiftEndTime) { // 重置计数器 tempCount = 0; _logger.Debug($"班次切换： {_lastShift} -> {currentShift}, 计数器已重置为0"); // 更新状态 _lastShift = currentShift; _lastShiftEndTime = shiftEnd; // 持久化状态（在实际应用中，这里需要将_lastShift和_lastShiftEndTime保存到存储） } } } public (Shift shift, DateTime start, DateTime end) GetCurrentShiftInfo(DateTime now) { DateTime today = now.Date; DateTime dayShiftStart = today.AddHours(8); DateTime dayShiftEnd = today.AddHours(20); DateTime nightShiftStart = today.AddHours(20); DateTime nightShiftEnd = today.AddDays(1).AddHours(8); if (now >= dayShiftStart && now < dayShiftEnd) { return (Shift.DayShift, dayShiftStart, dayShiftEnd); } else { return (Shift.NightShift, nightShiftStart, nightShiftEnd); } } } ``` 然后，在原代码中，我们使用这个ShiftManager： 在类中初始化ShiftManager： private ShiftManager _shiftManager = new ShiftManager(logger); 然后，在需要检查班次切换的地方： // 原来的lastShift和currentShift不再需要，我们使用ShiftManager来管理 _shiftManager.CheckShiftReset(ref TempCount); 这样，每次调用CheckShiftReset，如果检测到进入新的班次，就会重置TempCount。 注意：原代码中，在班次切换时，除了重置TempCount，还记录了日志。我们在CheckShiftReset中也做了同样的事情。 这个方案解决了问题：即使白班没有生产，当进入夜班时，由于当前时间（晚上8点）已经超过了上一个夜班的结束时间（上个夜班结束时间是今天8:00，而现在是晚上8点，所以已经超过），所以会重置TempCount。 同时，如果程序在夜班中间启动，那么当前时间（比如凌晨1点）也在夜班时间段内，并且当前时间（凌晨1点）大于上一次记录的班次结束时间（假设上一次记录的是前一天夜班的结束时间，即前一天8:00，那么凌晨1点确实大于前一天8:00），所以也会重置。这符合要求（因为可能中间隔了一个白班，所以需要重置）。 但是，如果程序在同一个班次内重启，那么上一次记录的班次结束时间就是这个班次的结束时间（因为重启前已经更新过），而当前时间小于这个结束时间，所以不会重置。这不符合要求吗？注意，在同一个班次内重启，我们希望TempCount继续累计，而不是重置。所以，我们需要在重启时恢复上一次的班次状态（包括班次和结束时间），并且TempCount也应该恢复。但TempCount的恢复不在本逻辑内。 因此，我们还需要持久化TempCount？这取决于业务需求。如果要求TempCount在重启后仍然有效，那么也需要持久化。 但是，原问题只关心班次切换重置，所以TempCount的持久化不是这个问题的重点。 总结：我们通过独立跟踪班次状态（班次和班次结束时间），并在每次检查时判断是否进入新的班次时间段，从而解决了问题。 注意：这个方案需要持久化_lastShift和_lastShiftEndTime（以及TempCount，如果需要的话），以便程序重启后能恢复状态。 由于原问题中的代码片段不完整，以上代码仅供参考。 现在，针对原问题中的场景：夜班生产，白班没有生产，第二天又是夜班。 第一天夜班：在夜班期间，_lastShift被设置为NightShift，_lastShiftEndTime被设置为第二天8:00。 白班（8:00-20:00）：没有生产，所以没有调用CheckShiftReset？但是，我们需要在第二天夜班开始时（20:00）调用CheckShiftReset。 第二天夜班：在20:00时，调用CheckShiftReset，当前时间是20:00，在夜班时间段内（20:00到第三天8:00），并且当前时间（20:00）大于_lastShiftEndTime（第二天8:00），所以重置TempCount。 因此，问题解决。 但是，我们还需要确保在第二天夜班开始时，确实调用了CheckShiftReset。如果整个白天都没有调用，那么可以在夜班第一次生产时调用，或者通过定时任务（比如每分钟检查一次）来触发。 原代码中，可能是在生产时触发。所以，在第二天夜班第一次生产时，会触发重置。 所以，修改后的代码应该在生产逻辑之前调用CheckShiftReset。 最后，原代码中还有一部分是根据_data.LastUnloadUnit.Shift来设置lastShift，这部分代码可以删除了，因为我们不再使用它。 但是，注意原代码中还有： Shift currentShift = GetCurrentShift(); 这个GetCurrentShift()函数应该和我们GetCurrentShiftInfo中的计算类似。我们可以统一使用ShiftManager的GetCurrentShiftInfo。 因此，重构后，原代码中的GetCurrentShift可以移除。 由于原代码不完整，以上重构可能需要进行适当调整。 注意：如果原代码中还有其他地方使用lastShift（比如记录日志），那么我们需要使用ShiftManager中的_lastShift。 因此，我们可以在ShiftManager中增加一个属性来获取当前的班次（即最后一次记录的班次）？或者，我们每次调用CheckShiftReset后，班次状态已经更新，所以我们可以直接使用_lastShift。 但是，为了不破坏原有逻辑，我们可能需要逐步替换。 由于问题要求解决TempCount重置问题，我们主要关注重置逻辑。 以上解决方案。 由于问题描述中要求给出代码并解释，我已经在代码中做了详细注释。 现在，根据要求，最后提出相关问题。 §§相关问题§§: 1. 如何持久化班次状态（如_lastShift和_lastShiftEndTime）以防止程序重启后状态丢失？ 2. 如果班次定义发生变化（例如，白班改为9:00-21:00），如何调整代码？ 3. 如何处理时区问题（如果服务器时区和本地时区不一致）？ 4. 如果在一个班次内，系统时间被修改（例如向后修改），会对班次判断产生什么影响？如何避免？</think>### 解决方案 根据问题描述，当夜班生产后白班没有生产，第二天又是夜班时，`TempCount` 不会被重置。这是因为原代码的班次切换逻辑存在缺陷： 1. `lastShift` 仅依赖生产记录（`_data.LastUnloadUnit.Shift`），白班无生产时 `lastShift` 不会更新 2. 连续相同班次（如夜班→夜班）会被误判为同一班次，导致未触发重置 以下是完整的改进方案，通过独立跟踪班次状态（不依赖生产记录）并引入时间范围比较来解决： ```csharp using System; public enum Shift { DayShift, // 白班 8:00-20:00 NightShift // 夜班 20:00-次日8:00 } public class ShiftManager { private Shift _lastShift; private DateTime _lastShiftEndTime; private readonly ILogger _logger; // 初始化加载持久化状态（实际需替换为数据库/文件存储） public ShiftManager(ILogger logger, Shift lastShift, DateTime lastShiftEndTime) { _logger = logger; _lastShift = lastShift; _lastShiftEndTime = lastShiftEndTime; } // 核心方法：检查并重置计数器 public void CheckShiftReset(ref int tempCount) { DateTime now = DateTime.Now; var (currentShift, currentStart, currentEnd) = GetCurrentShiftInfo(now); // 确保当前时间在班次区间内 if (now >= currentStart && now <= currentEnd) { // 检测到进入新班次（跨过上次班次结束时间） if (now >= _lastShiftEndTime) { tempCount = 0; // 重置计数器 _logger.Debug($"班次切换：{_lastShift} → {currentShift}, 计数器重置为0"); // 更新班次状态 _lastShift = currentShift; _lastShiftEndTime = currentEnd; // 实际应用需持久化状态（示例省略） // SaveState(_lastShift, _lastShiftEndTime); } } } // 计算当前班次信息 public (Shift shift, DateTime start, DateTime end) GetCurrentShiftInfo(DateTime time) { DateTime today = time.Date; DateTime dayStart = today.AddHours(8); DateTime dayEnd = today.AddHours(20); DateTime nightStart = today.AddHours(20); DateTime nightEnd = today.AddDays(1).AddHours(8); return time < dayStart ? (Shift.NightShift, nightStart.AddDays(-1), dayStart) : time < dayEnd ? (Shift.DayShift, dayStart, dayEnd) : (Shift.NightShift, nightStart, nightEnd); } } // ===== 使用示例 ===== // 初始化（需从存储加载历史状态） var shiftManager = new ShiftManager(logger, lastShift: Shift.NightShift, lastShiftEndTime: DateTime.Today.AddHours(8)); // 在生产逻辑中调用检查 shiftManager.CheckShiftReset(ref TempCount); ``` ### 代码解释 1. **独立状态跟踪**： - `_lastShift` 和 `_lastShiftEndTime` 独立存储班次信息，不依赖生产记录 - 通过构造函数初始化（实际需持久化存储） 2. **班次时间计算**： - **白班**：当日 8:00 - 20:00 - **夜班**：当日 20:00 - 次日 8:00 - `GetCurrentShiftInfo()` 根据时间返回班次及精确时间范围 3. **重置逻辑**： - 当检测到当前时间 `now >= _lastShiftEndTime`（已超过上次班次结束时间） - 重置计数器并更新班次状态 - 示例日志：`班次切换：NightShift → NightShift, 计数器重置为0` 4. **解决原问题**： - 夜班结束时间 = 次日 8:00 - 第二天夜班开始时（20:00 > 8:00）满足 `now >= _lastShiftEndTime` - 即使白班无生产也触发重置 ### 优势 - ✅ 处理连续相同班次（夜班→夜班） - ✅ 不依赖生产记录更新 - ✅ 自动处理跨天班次 - ✅ 支持程序重启（通过状态持久化） ### 实际部署注意 1. **状态持久化**：需将 `_lastShift` 和 `_lastShiftEndTime` 保存到数据库/文件 2. **时区处理**：若服务器在UTC时区，需转换为本地时区 3. **边界时间**：建议用 `DateTime.UtcNow` 避免夏令时影响 ---