Discussion :

[amalliap]

Bonjour,

Je suis actuellement à la recherche d'un solution pour obtenir le nombre d'heure (double) compris entre deux plages horaires à partir de deux date time différent (Start, End).

Par exemple, je dispose de deux composants DateTime, par exemple : StartDateTime = "01/01/2016 02:00:00" et EndDateTime = "01/01/2016 10:00:00"

Et je souhaiterais obtenir le nombre d'heures qu'il y a entre 23h et 5h00, entre 5h00 et 6h00..

Quelle est la meilleurs solution selon vous ?

Merci d'avance.

[ZenZiTone]

Bonjour, tu peux effectuer des opérations sur les DateTime

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
  Dim T1 = DateTime.Now
        Dim T2 = DateTime.Now.AddHours(-2).AddDays(-1)
 
        Console.WriteLine((T1 - T2).ToString)

tu auras un résultat de type TimeSpan -> temps écoulé. Tu auras ainsi accès à plusieurs propriétés intéressantes telles que le nombre de jours, heure, etc...

[WaterTwelve21]

Bonjour , en effet comme le dit ZenZitone , travailler sur le timespan est une bonne idée .
J'ai une question , tu souhaite seulement retourner l'intervalle en heure brute ou en format heures/minutes/secondes?

Un bon procédé serai de faire une méthode acceptant en paramètre deux DateTime (début et fin ) y calculer le timeSpan à partir des deux dates par exemple de cette manière :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

TimeSpan ts = new TimeSpan(EndDate.Ticks - StartDate.Ticks

Ensuite tu regardes les propriétés qu'offrent le TimeSpan et tu devrai t'en sortir

[PatteDePoule]

En fait soustraire 2 DateTime donne un TimeSpan.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
DateTime start = DateTime.Now.AddHours(-6);
DateTime end = DateTime.Now;
TimeSpan difference = end - start;

[amalliap]

Je ne veux pas calculer la différence entre deux TimeSpan, je veux savoir le nombre d'heures compris dans une plage horaire..

[ebastien]

Il y a 3 semaines, tu as eu toutes les réponses nécessaires pour faire ce que tu veux et tu n'as toujours pas réussi ?

[amalliap]

J'étais passé à autres choses depuis. J'ai une méthode qui pour moi est une grosse usine à gaz donc je demandais juste si quelqu'un avais une autre façon de penser que moi.

[jopopmk]

Salut,

le fait que tu n'aies pas la réponse voulue vient peut-être du fait que la question est difficile à comprendre. Ton énoncé :

[..]Par exemple, je dispose de deux composants DateTime, par exemple : StartDateTime = "01/01/2016 02:00:00" et EndDateTime = "01/01/2016 10:00:00"

Et je souhaiterais obtenir le nombre d'heures qu'il y a entre 23h et 5h00, entre 5h00 et 6h00..[..]

Là, comme ça, je comprends pas. 23h-5h/5h-6h n'ont aucun rapport avec tes deux DateTimes.

En fait ce que tu cherches à faire c'est trouver le nombre d'heures en commun (ou chevauchement) pour deux périodes ?
En nous montrant le code de ton "usine à gaz" on comprendra peut-être mieux ton besoin

[François DORIN]

Je ne veux pas calculer la différence entre deux TimeSpan, je veux savoir le nombre d'heures compris dans une plage horaire..

Tu as mal lu la réponse qui t'a été faite. Il ne s'agit pas de faire une différence entre deux TimeSpan, mais de faire une différence entre deux DateTime. Et faire une différence entre deux DateTime te retourne un TimeSpan. Une fois que tu as ton TimeSpan, tu peux accéder au nombre d'heures constituant la plage via la propriété TotalHours.

[amalliap]

Excusez moi si je me suis mal exprimé mais c'est assez complexe à expliquer ;-)

Je vais prendre un cas concret :

Je veux sortir un formulaire qui va lister le nombres d'heures d'intervention d'une personne dans un mois.

Par exemple : Monsieur XXXX a effectuer 1 intervention de 3H. (On va dire de 19H à 22H).

Seulement lorsque mon formulaire va être envoyé à la paye, il y a plusieurs plages horaires qui ne sont pas rémunéré pareil (21H-23H ; 23H-00H ; 00H-05H et 05H-06H)

Donc il faut que je dise dans mon formulaire que Monsieur X a effectué 1 intervention de 3H avec 1H comprise dans la plage horaire de 21H-23H.

Je recherche donc une fonction afin de calculer cela.

Voici mon usine à gaz ^^

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
public double GetHour(int idUser,string date,string startDate, string endDate)
        {
            double totalHour = 0;
 
 
            string month = "";
            switch (date.Substring(5, 2))
            {
                case "01": month = "1"; break;
                case "02": month = "2"; break;
                case "03": month = "3"; break;
                case "04": month = "4"; break;
                case "05": month = "5"; break;
                case "06": month = "6"; break;
                case "07": month = "7"; break;
                case "08": month = "8"; break;
                case "09": month = "9"; break;
                case "10": month = "10"; break;
                case "11": month = "11"; break;
                case "12": month = "12"; break;
 
            }
            foreach (var intervention in InterventionCollection.GetAll(idUser))
            {
                if (intervention.StartDate.Year.ToString() == date.Substring(0, 4) && intervention.StartDate.Month.ToString() == month)
                {
                    if (intervention.StartDate.Subtract(DateTime.ParseExact(intervention.EndDate.Date.ToString("yyyy-MM-dd") + " "+ startDate, "yyyy-MM-dd H:mm:ss", provider)).TotalHours == 0 && intervention.EndDate.Subtract(DateTime.ParseExact(intervention.EndDate.Date.ToString("yyyy-MM-dd") + " "+endDate, "yyyy-MM-dd H:mm:ss", provider)).TotalHours == 0 && intervention.StartDate.ToString("dddd", provider).ToUpper() != "DIMANCHE")
                    {
                        totalHour = totalHour + intervention.EndDate.Subtract(intervention.StartDate).TotalHours;
                    }
 
                    if (intervention.StartDate.Subtract(DateTime.ParseExact(intervention.EndDate.Date.ToString("yyyy-MM-dd") + " "+startDate, "yyyy-MM-dd H:mm:ss", provider)).TotalHours < 0 && intervention.EndDate.Subtract(DateTime.ParseExact(intervention.EndDate.Date.ToString("yyyy-MM-dd") + " "+endDate, "yyyy-MM-dd H:mm:ss", provider)).TotalHours > 0 && intervention.StartDate.ToString("dddd", provider).ToUpper() != "DIMANCHE")
                    {
                        DateTime dateTime = DateTime.ParseExact(intervention.EndDate.Date.ToString("yyyy-MM-dd") + " "+startDate, "yyyy-MM-dd H:mm:ss", provider);
                        DateTime dateTime2 = DateTime.ParseExact(intervention.EndDate.Date.ToString("yyyy-MM-dd") + " "+endDate, "yyyy-MM-dd H:mm:ss", provider);
                        totalHour = totalHour + dateTime2.Subtract(dateTime).TotalHours;
                    }
 
                    if (intervention.StartDate.Subtract(DateTime.ParseExact(intervention.EndDate.Date.ToString("yyyy-MM-dd") + " "+startDate, "yyyy-MM-dd H:mm:ss", provider)).TotalHours > 0 && intervention.EndDate.Subtract(DateTime.ParseExact(intervention.EndDate.Date.ToString("yyyy-MM-dd") + " "+endDate, "yyyy-MM-dd H:mm:ss", provider)).TotalHours < 0 && intervention.StartDate.ToString("dddd", provider).ToUpper() != "DIMANCHE")
                    {
                        totalHour = totalHour + intervention.EndDate.Subtract(intervention.StartDate).TotalHours;
                    }
 
                    if (intervention.StartDate.Subtract(DateTime.ParseExact(intervention.EndDate.Date.ToString("yyyy-MM-dd") + " "+startDate, "yyyy-MM-dd H:mm:ss", provider)).TotalHours >= 0 && intervention.StartDate.Subtract(DateTime.ParseExact(intervention.EndDate.Date.ToString("yyyy-MM-dd") + " "+endDate, "yyyy-MM-dd H:mm:ss", provider)).TotalHours < 0 && intervention.EndDate.Subtract(DateTime.ParseExact(intervention.EndDate.Date.ToString("yyyy-MM-dd") + " "+endDate, "yyyy-MM-dd H:mm:ss", provider)).TotalHours > 0 && intervention.StartDate.ToString("dddd", provider).ToUpper() != "DIMANCHE")
                    {
                        DateTime dateTime2 = DateTime.ParseExact(intervention.EndDate.Date.ToString("yyyy-MM-dd") + " "+endDate, "yyyy-MM-dd H:mm:ss", provider);
                        totalHour = totalHour + dateTime2.Subtract(intervention.StartDate).TotalHours;
                    }
 
                    if (intervention.StartDate.Subtract(DateTime.ParseExact(intervention.EndDate.Date.ToString("yyyy-MM-dd") + " "+startDate, "yyyy-MM-dd H:mm:ss", provider)).TotalHours < 0 && intervention.EndDate.Subtract(DateTime.ParseExact(intervention.EndDate.Date.ToString("yyyy-MM-dd") + " "+endDate, "yyyy-MM-dd H:mm:ss", provider)).TotalHours < 0 && intervention.EndDate.Subtract(DateTime.ParseExact(intervention.EndDate.Date.ToString("yyyy-MM-dd") + " "+startDate, "yyyy-MM-dd H:mm:ss", provider)).TotalHours > 0 && intervention.StartDate.ToString("dddd", provider).ToUpper() != "DIMANCHE")
                    {
                        DateTime dateTime2 = DateTime.ParseExact(intervention.EndDate.Date.ToString("yyyy-MM-dd") + " "+startDate, "yyyy-MM-dd H:mm:ss", provider);
                        totalHour = totalHour + intervention.EndDate.Subtract(dateTime2).TotalHours;
                    }
                }
            }
 
            return totalHour;
        }

On note que les arguments startDate et endDate de la fonction sont de type '23:00:00' par exemple

[François DORIN]

C'est beaucoup plus clair ainsi

Donc, effectivement, ton code est une usine à gaz, et difficile à lire (donc à maintenir !).

Juste pour être sur au niveau des entrées :

• userId : Utilisateur pour lequel tu veux connaitre le nombre d'heure effectuée durant une plage horaire spécifiée ;
• date : la date où se situe la plage horaire que tu souhaites vérifier (par ex. le 22/07/2016);
• startDate : l'heure de début de la plage horaire à vérifier (le 21h de ton exemple);
• endDate : l'heure de fin de la plage horaire à vérifier (le 23h de ton exemple).

La fonction itère donc ensuite sur l'ensemble des interventions de ton utilisateur (boucle foreach InterventionCollection.GetAll(idUser)) pour déterminer s'il y a eu une intervention le 22/07/2016 entre 21h et 23h, et si oui, le nombre d'heures effectivement exécutée durant cette plage horaire.

En réalité, en lisant ton code, ce n'est pas pour une date précise que tu cherches le nombre d'heure, mais pour un mois pour une année précise. Donc, si en entrée de ta fonction, tu passes dans le paramètre date "22/07/2016", tu souhaites calculer le nombre d'heures effectuées durant le mois de juillet 2016 entre 21h et 23h. Sauf si le jour est un dimanche (dans ce cas, le jour n'est pas comptabilisé).

J'ai bien résumé la finalité de ta fonction ?

[amalliap]

C'est exactement ça ! :-)

Oui je recherche le nombres d'heure pour une personne par moi, afin d’éditer un pdf.

Pour ma fonction j'essaye de traiter le plus de cas possible mais je me rend compte qu'il y a des incohérences dans mes résultats..

[ericlm128]

Il me semble plutôt que l'entré date est au format "YYYY/MM/JJ".

intervention.StartDate et intervention.EndDate sont des datetimes ?

[amalliap]

Oui se sont des datetimes avec la même dates mais des horaires différentes.

Je crois qu'il y a une sorte d’algorithme nommé Planning Strategy qui existe, notamment pour la plannification des horaires de vols pour pas que ceux ci se chevauche mais ça m'a l'air assez complexe et je pense qu'il y à plus simple pour un cas comme le miens..

[ericlm128]

Voici une proposition

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Simulation des paramètres d'entrées
string userId = "123456";
string date = "2016/07/22";
string startDate = "21:00:00";
string endDate = "05:00:00";
 
// On type correctement les données d'entrées (ça devrait être les types des paramètres d'entrées)
int Year = DateTime.ParseExact(date, "yyyy/MM/dd", CultureInfo.InvariantCulture).Year;
int Mounth = DateTime.ParseExact(date, "yyyy/MM/dd", CultureInfo.InvariantCulture).Month;
int HourStartLimit = DateTime.ParseExact(startDate, "HH:mm:ss", CultureInfo.InvariantCulture).Hour;
int HourEndLimit = DateTime.ParseExact(endDate, "HH:mm:ss", CultureInfo.InvariantCulture).Hour;
 
// On définit les heures valides
List<int> HoursEligible = new List<int>();
for (int i = HourStartLimit; i <= ((HourStartLimit <= HourEndLimit) ? HourEndLimit : HourEndLimit + 24); i++)
    HoursEligible.Add(i < 24 ? i : i - 24);
 
// On créées une liste qui contiendra toutes les heures travaillés (le résultat)
List<int> Heures = new List<int>();
 
// On cherche les heures travaillés
foreach (var intervention in InterventionCollection.GetAll(idUser))
    for (DateTime item = intervention.StartDate; item <= intervention.EndDate; item = item.AddHours(1))
        if (item.Year == Year && item.Month == Mounth && HoursEligible.Contains(item.Hour) && item.DayOfWeek != DayOfWeek.Sunday)
            Heures.Add(item.Hour);
 
 
// Nombre total d'heures
int totalhours = Heures.Count();
 
// Nombre d'heures entre 21H-23H 
int hours_21_23 = Heures.Count(x => (new List<int> { 21, 22, 23}).Contains(x));
 
// Nombre d'heures entre 00H-05H  
int hours_00_05 = Heures.Count(x => (new List<int> { 0, 1, 2, 3, 4, 5 }).Contains(x));

[François DORIN]

Petite proposition :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public static double GetHour(int idUser, string date, string startTime, string endTime)
        {
            DateTime period = DateTime.ParseExact(date, "yyyy-MM-dd", null);
            DateTime start = DateTime.ParseExact(startTime, "H:mm:ss", null);
            DateTime end = DateTime.ParseExact(endTime, "H:mm:ss", null);
            double totalHour = 0;
 
            foreach (var intervention in InterventionCollection.GetAll(idUser))
            {
                if (intervention.StartDate.Year == period.Year && intervention.StartDate.Month == period.Month &&
                    intervention.StartDate.DayOfWeek != DayOfWeek.Sunday)
                {
                    DateTime startPeriod = new DateTime(intervention.StartDate.Year,
                                                        intervention.StartDate.Month,
                                                        intervention.StartDate.Day,
                                                        start.Hour,
                                                        start.Minute,
                                                        start.Second);
                    DateTime endPeriod = new DateTime(intervention.StartDate.Year,
                                                        intervention.StartDate.Month,
                                                        intervention.StartDate.Day,
                                                        end.Hour,
                                                        end.Minute,
                                                        end.Second);
 
                    if ((startPeriod <= intervention.StartDate && intervention.StartDate <= endPeriod) ||
                        (startPeriod <= intervention.EndDate && intervention.EndDate <= endPeriod))
                    {
                        // L'intervention chevauche la plage horaire. Il reste à calculer la plage effective
                        TimeSpan duree;
                        if (startPeriod <= intervention.StartDate)
                        {
                            startPeriod = intervention.StartDate;
                        }
 
                        if (intervention.EndDate <= endPeriod)
                        {
                            endPeriod = intervention.EndDate;
                        }
 
                        duree = endPeriod - startPeriod;
                        totalHour += duree.TotalHours;
                    }
                }               
            }
 
            return totalHour;
        }

Limitation du code : il y a un cas qui n'est pas géré, celui où une période commence une journée et finie le lendemain. Par exemple, si tu recherches les périodes qui commencent à 23h00 le soir et qui se finissent à 01h00 le lendemain matin, le comportement est indéfini. Il faut ou bien adapter le code, ou bien séparer ta plage horaire en deux.

[ericlm128]

Petite proposition :
Limitation du code : il y a un cas qui n'est pas géré, celui où une période comme une journée et fini le lendemain. Par exemple, si tu recherches les périodes qui commencent à 23h00 le soir et qui se finissent à 01h00 le lendemain matin, le comportement est indéfini. Il faut ou bien adapté le code, ou bien séparer ta plage horaire en deux.

Pour ce cas, j'ai préféré chercher les heures valides avant de commencer le traitement.

[François DORIN]

Pour ce cas, j'ai préféré chercher les heures valides avant de commencer le traitement.

Je ne l'ai pas fait pour des raisons de simplicité. Mais le paliatif est simple, puisqu'il suffit de vérifier que l'heure de fin et postérieure à l'heure de début. Si ce n'est pas le cas, il suffit de rajouter un jour à la date de fin de la période.

Maintenant, j'ai proposé mon algo car ton algo a un défaut (bon, c'est aussi parce que je n'ai vu le tiens qu'une fois que j'avais fini le mien ) : il ne travaille qu'avec des heures pleines.

[ericlm128]

Oui, j'ai cru comprendre que ce n'était que des heures pleines.

Si ce n'est pas le cas, il suffit de rajouter un jour à la date de fin de la période.

Tout comme le fait que l'employer ne peut pas effectuer une intervention de 48h d'affilé, sur 2 jours.

[ericlm128]

Mis à part le fait que ton script ne gère pas sur deux jours, il peut nous dire combien d'heures travaillés entre 21H-23H ; 23H-00H ; 00H-05H et 05H-06H ?