J'essaie de construire un outil qui calcule quelque chose appelé quota basé sur lorsque les employés devraient travailler et quand ils demandent. P>
My ShiftSet Object est un ensemble d'objets de décalage consistant en une heure de départ et de la durée de déroute (à la fois du temps de type (7). Chaque change correspond à une journée. P>
La planification des exceptions sont des moments où un employé est désactivé. Il peut y avoir n'importe quel nombre de clandestines qui se chevauchent ou non qui se chevauchent dans une journée. Ils sont du type de données DateTime. P>
Un exemple de changeage:
08h00-10: 00
10h00-12h00
13h00-15: 00
15h00-17: 00 P>
Un exemple de forfaits exceptionnels pour le même jour:
07: 30-10: 30
14: 35-16: 00 P>
Ce que je dois faire est de trouver le temps que l'employé travaille un jour. La façon dont je peux figurer pour le faire est de calculer l'intersection de ShifseSet et l'inverse des ordres de la planification. P>
Comment ferais-je cela avec le temps? Je préférerais utiliser Linq si possible. P>
4 Réponses :
Consultez cet excellent Article à codeProject p>
C'est probablement trop large pour votre problème spécifique, mais cela vous donnera probablement un bon point de départ sur la façon de le résoudre. P>
Comme indiqué entre cela, il existe des bibliothèques qui ont résolu ce problème, mais ils résolvent également de nombreux problèmes connexes. Si vous souhaitez simplement aborder ce problème particulier sans prendre une autre dépendance, vous pouvez essayer ce qui suit. C'est un exemple de base, bien qu'il puisse être compacté (bien que moins lisible) et amélioré. p> p>
Je n'ai pas testé le code ci-dessous, peut-il y avoir des bugs, aussi je l'ai écrit dans textpad peut être des caractères non valides, une idée est simple et j'essaie d'utiliser des variables significatives.
var orderedShifts = ShiftSets.OrderBy(x=>x.StartDate).ToList();
var compactShifts = new List<Shift>();
compactShifts.Add(orderedShifs[0]);
foreach (var item in orderedShift)
{
if (item.Start <= compactShifts[compactShifts.Count-1].End
&& item.End > compactShifts[compactShifts.Count-1].End)
{
compactShifts[compactShifts.Count-1].End = item.End;
}
else if (item.Start > compactShifts[compactShifts.Count-1].End)
compactShifts.Add(item);
}
//run similar procedure for schedule exceptions to create compact schedules.
var validShifts = new List<Shift>();
foreach (var item in compactShifts)
{
var shiftCheatingPart = compactExceptions
.FirstOrDefault(x=>x.Start < item.Start
&& x.End > item.End)
if (shiftCheatingPart != null)
{
if (item.End <= shiftCheatingPart.End)
continue;
validShifts.Add(new Shift{Start = shiftCheatingPart.End,End = item.End);
}
}
var totalTimes = validShifts.Sum(x=>x.End.Sunbtract(x.Start).TotalHours);
Une solution très brute serait quelque chose comme I Calculez une durée de travail en quelques minutes pour que je puisse résumer plus facilement à l'aide de LINQ P> Je suis également manquant des informations de décalage spécifiques que je pense n'appartire pas avec shiftset code> classe p> car l'employé n'est pas prévu de fonctionner de 7h30 à 8h00, nous n'incluions pas ce temps code> p> p>
Puis-je vous demander quel type
(7) code> est en C #?C'est l'heure dans SQL, mais en C # c'est une période de temps.
Avez-vous besoin de trouver le temps total, ou souhaitez-vous trouver les heures de départ / fin de départ d'un employé?
Vous voulez trouver la somme de toutes les heures que quelqu'un a travaillé dans une journée. Dans votre exemple ci-dessus, ce serait
8h - 4h25m = 3h35m code>?Vous dites que vous utilisez Timespan, mais vous mentionnez des horaires (c'est-à-dire
DateTime code> serait approprié). Itispan code> n'a pas de début et une fin, seulement une période de temps.@Circadian, presque. Parce que l'employé n'est pas prévu de travailler de 7h30 à 8h00, nous n'incluions pas ce délai.
Timespan CODE> est l'entité d'entitéFramework de type par défaut utilise pour la gestion du type code> SQL code>.Timespan code> est acceptable ici, bien que DateTime puisse fonctionner aussi bien. Il est clair que l'intention est de décomposer des segments de temps à des fins de planification et d'utiliser des segments d'exception pour supprimer des gammes conflictuelles. Ma réponse ci-dessous répond à ce problème.