Récupérer une date a partir d'un numero de semaine et d'un nom de jour

Version imprimable

09/07/2013, 16h41
Invité

Récupérer une date a partir d'un numero de semaine et d'un nom de jour

Bonjour,

Connaissez vous un moyen pour récupérer une date a partir d'un numero de semaine et d'un nom de jour ? ex:
Semaine 28 + Mardi = 09/07/2013

Merci pour toute aide.
09/07/2013, 16h56
Guulh

Hello,
rien de natif dans le framework. Mais si t'analyses le truc, en le découpant en petit morceaux, c'est simple. Il te faut:
- déterminer quel jour commence la première semaine. Selon l'année, ça peut aller du 29/12 de l'année d'avant au 5/1 de l'année en question
- une fois que t'as ça, tu peux calculer la date du lundi de la semaine 28
- une fois que t'as ça, tu peux calculer la date du mardi de la semaine 28.

Fouille la MSDN et l'objet DateTime, notamment ses méthodes et propriétés http://msdn.microsoft.com/fr-fr/libr...e.adddays.aspx, DayOfWeek.

Code:

1 2 DateTime date = DateTime.Now; date= date.AddDays(7 * 28);
il faut un DateTime de base 28 semaine de l’année par exemple
Code:

1 2 DateTime date = new DateTime(2013, 1, 1); date= date.AddDays(7 * 28);
mais pour le nom du jours ???

explique moi le besoin ?

09/07/2013, 17h26
SLiM_ViNCe

Comment fais-tu pour déterminer l'année dans laquelle tu cherches ? Je suppose que c'est nécessairement l'année courante car pour ton exemple, ça ne donnerait pas la même date avec 2012.

Après effectivement, pour trouver la semaine 28, le calcul d'azstar semble pas mal.
Pour retrouver un jour à partir de son nom, tu peux peut être t'en sortir avec la liste des noms de jour pour une culture donnée :

Code:

System.Globalization.DateTimeFormatInfo.CurrentInfo.DayNames

L'indice dans le tableau donne le n° du jour dans la semaine.
A adapter pour la culture "fr-fr" je suppose.

Bonsoir,
suite à cette discussion.
Ce qui pourrait donner :

Code:

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
        Dictionary<string, DayOfWeek> dictDays =
            new Dictionary<string, DayOfWeek>();
 
        private void Form1_Load(object sender, EventArgs e)
        {
            dictDays.Add("dimanche", DayOfWeek.Sunday);
            dictDays.Add("lundi", DayOfWeek.Monday);
            dictDays.Add("mardi", DayOfWeek.Tuesday);
            dictDays.Add("mercredi", DayOfWeek.Wednesday);
            dictDays.Add("jeudi", DayOfWeek.Thursday);
            dictDays.Add("vendredi", DayOfWeek.Friday);
            dictDays.Add("samedi", DayOfWeek.Saturday);
        }
 
        private DateTime GetDayOfWeekDict(int year, int weekNumber, string dayWeek)
        {
 
            DateTime value = new DateTime(year, 1, 1).AddDays(7 * weekNumber);
 
            int daysToAdd = 0;
            DayOfWeek day;
 
            if (dictDays.TryGetValue(dayWeek.ToLower(),out day).Equals(DayOfWeek.Sunday))
            {
                daysToAdd = 7 - Convert.ToInt32(value.DayOfWeek);
            }
            else
            {
                daysToAdd = Convert.ToInt32(day) - Convert.ToInt32(value.DayOfWeek);
            }
 
            if (Convert.ToInt32(new DateTime(value.Year, 1, 1).DayOfWeek) < 5)
            {
                daysToAdd -= 7;
            }
 
            return value.AddDays(daysToAdd);
 
        }

Utilisation :

Code:

1
2
3
4
5
            int year = 2010;
            int week = 13;
            string day = "Dimanche";
 
            textBox1.Text = GetDayOfWeekDict(year, week, day).ToShortDateString();

Comme dit précédemment, il faut l'année.
A tester...

D'après numérotation ISO des semaines (wikipedia) la semaine n°1 commence toujours soit au 1er janvier si celui-ci est un lundi, soit au lundi précédent. Si on souhaite suivre sa convention (donc ne pas tenir compte de la culture US où les semaines commencent le dimanche), alors le code suivant fonctionne et est plus lisible à mon goût :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
        DateTime GetDay(int year, int week /* commence à 1 */, DayOfWeek dayOfWeek)
        {
            // 1er janvier à 12h00
            var date = new DateTime(year, 1, 1, 12, 0, 0);
 
            // Jour désiré de la semaine n°1 (l'énum DayOfWeek commence le dimanche)
            int wantedDay = ((int)dayOfWeek + 6) % 7;
            int currentDay = ((int)date.DayOfWeek + 6) % 7;
            int dayShift = wantedDay - currentDay;
            date.AddDays(dayShift);
 
            // Ajoute X semaines
            return date.AddDays((week - 1) * 7);
        }

10/07/2013, 08h45
Invité

Merci pour a vous tous pour vos exemples de code !
Je vais les tester et vous dirais lequel me convient le mieux (le plus rapide).

Finalement j'ai fait un truc a ma sauce. Voila le résultat:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Dictionary<string, int> dicDays = new Dictionary<string, int>(){
            {"mardi", 0 },
            {"mercredi", 1},
            {"jeudi", 2 },
            {"vendredi", 3 },
            {"samedi", 4 },
            {"dimanche", 5 },
            {"lundi", 6 }
         };
         int week = 28;
         string day = "mercredi";
         Calendar cal = System.Globalization.DateTimeFormatInfo.CurrentInfo.Calendar;
         DateTime dt;
 
         dt = new DateTime(1, 1, 1); // 01/01/0001
         dt = cal.AddWeeks(dt, week - 1);
         dt = cal.AddDays(dt, dicDays[day]); //  10/07/0001
         dt = DateTime.Parse(DateTime.Now.Year.ToString() + "/" + dt.Month.ToString() + "/" + dt.Day.ToString()); // 10/07/2013

Si vous voyez un cas dans lequel cela pourrait ne pas fonctionner merci de m'en faire part :)
Note : J'imagine qu'il y aura un problème lors des année bissextiles avec le mois de février.

10/07/2013, 10h29
Invité

Okay,j'ai recontré plusieurs problèmes venant du fait que mardi doit être considéré comme le premier jour de la semaine pour que cela fonctionne.
Un idée pour contourner cela ?
10/07/2013, 11h23
chrisdot

Tu utilises l'année 0001 pour faire tes calculs, c'est normal? je pense que ça fous la m... Toutes les années ne commencent pas ainsi ! (faudrait peut être prendre l'année courante)
Il faudrait revoir ton postulat de base:

Citation:

Année concernée + Semaine 28 + Mardi = 09/07/2013
10/07/2013, 11h53
Invité

Si seulement c'était aussi simple ^^'
Je n'ai pas trouvé le moyen pour ajouter "mardi" dans une date. Et cela semble logique étant donnée qu'on ne saurait pas s'il s'agit du précédent ou du suivant.

Le coeur du problème vient du fait que pas toutes les années commence par un lundi, si j'ajoute 28 semaines a l'année 2013, je tombe sur un autre jour que lundi.
J'ai voulu contourner le problème en passant pas 01/01/0001. Mais je pense qu'au final le problème est toujours là étant donné que je suis obligé de donner des valeurs étranges a mes jours.

Un truc comme ça?

Code:

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
 
	class Program
	{
		static void Main(string[] args)
		{
 
 
 
            dictDays.Add("dimanche", DayOfWeek.Sunday);
            dictDays.Add("lundi", DayOfWeek.Monday);
            dictDays.Add("mardi", DayOfWeek.Tuesday);
            dictDays.Add("mercredi", DayOfWeek.Wednesday);
            dictDays.Add("jeudi", DayOfWeek.Thursday);
            dictDays.Add("vendredi", DayOfWeek.Friday);
            dictDays.Add("samedi", DayOfWeek.Saturday);
 
 
			int year = 2013;
			int week = 28;
			string day = "mardi";
 
 
			Console.WriteLine("{0}", GetSundayOfWeek(year, week).AddDays((int)dictDays[day]));
 
			Console.ReadLine();
 
		}
 
 
		private static Dictionary<string, DayOfWeek> dictDays = new Dictionary<string, DayOfWeek>();
 
		//ISO
		public static DateTime GetSundayOfWeek(int Year, int WeekNumber)
		{
			DateTime start = new DateTime(Year, 1, 1);
			start = start.AddDays(-((int)start.DayOfWeek));
			start = start.AddDays(7 * (WeekNumber - 1));
			return start;
		}
 
	}

Inspiré d'ici.

10/07/2013, 13h50
Invité

C'est parfait, merci beaucoup !

Bonjour,
il reste le soucis des années commençant par vendredi, samedi ou dimanche.
Selon la norme, ils appartiennent à l'année précédente.

Citation:

Si le 1er janvier de l'année est un vendredi : les vendredi 1er, samedi 2 et dimanche 3 janvier de l'année font partie de l'année précédente ISO.

D'où un résultat décalé d'une semaine sauf erreur pour une année comme 2010 par exemple.

En reprenant l'idée du dico string - int plus la numérotation ISO des jours, ça peut donner ça :

Code:

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
            //Jour int ISO
            Dictionary<string, int> dicDays = new Dictionary<string, int>()
            {
                {"lundi", 1 }, 
                {"mardi", 2 },
                {"mercredi", 3},
                {"jeudi", 4 },
                {"vendredi", 5 },
                {"samedi", 6 },
                {"dimanche", 7 }            
            };
 
            int year = 2010;  // DateTime.Now.Year;
            int week = 2;
            string day = "lundi";
 
            DateTime value = new DateTime(year, 1, 1).AddDays(7 * week);
 
            int daysToAdd = dicDays[day.ToLower()];
 
            // On contrôle si l'année commence après jeudi si oui on décale d'une semaine.
            if ((int)new DateTime(value.Year, 1, 1).DayOfWeek < 5)
            {
                daysToAdd -= (int)value.DayOfWeek + 7;
            }
            else
            {
                daysToAdd -= (int)value.DayOfWeek;
            }
 
            Console.WriteLine("{0}", value.AddDays(daysToAdd).ToShortDateString());

Oui, apparemment en Europe, la semaine n°1 est celle qui contient le 04 janvier.
Donc GetSundayOfWeek devient:
Code:

1 2 3 4 5 6 7 8 9 //ISO public static DateTime GetSundayOfWeek(int Year, int WeekNumber) { DateTime start = new DateTime(Year, 1, 4); start = start.AddDays(-((int)start.DayOfWeek)); start = start.AddDays(7 * (WeekNumber - 1)); return start; }

10/07/2013, 16h36
chrismonoye

+1