MetaTrader 5
Experts
Indicateurs
Scripts
Bibliothèque
StockageRejoignez notre page de fans
- Vues:
- 132
- Note:
- Publié:
-
Vous manquez des opportunités de trading :- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription Se connecterVous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire -
Besoin d'un robot ou d'un indicateur basé sur ce code ? Commandez-le sur Freelance
Aller sur Freelance
Bonjour, chers traders.
Cette bibliothèque contient toutes les fonctions permettant d'obtenir l'heure locale actuelle sur un marché spécifique ou sur tous les marchés du Forex. Vous pouvez convertir les heures locales entre les fuseaux horaires ou à l'heure du serveur de votre courtier. Vous pouvez également négocier dans des sessions spécifiques en définissant les heures de début et de fin de session pour chaque session, séparément. La bibliothèque prend en charge les différents décalages horaires et les changements d'heure de la journée du courtier et de ces marchés. Vous n'avez donc pas à réinventer la roue chaque fois que vous programmez un conseiller expert ou un indicateur technique qui doit tenir compte des fuseaux horaires et des heures des sessions locales.
Qu'est-ce que le fuseau horaire ?
Le fuseau horaire est défini comme l'heure standard en fonction de la représentation géographique de ce lieu. En d'autres termes, le fuseau horaire fait référence à l'heure locale d'une région particulière en fonction de la rotation de la terre. Il est défini en UTC (temps universel coordonné), la norme par rapport à laquelle l'heure de chaque région du monde est coordonnée.
Par exemple, l'heure à New York est en retard de 5 heures par rapport à Greenwich et est représentée par UTC-5 ou UTC-4 en fonction de la lumière du jour. L'heure à Sydney est en avance de 10 heures sur Greenwich et représentée par UTC+10 ou UTC+11 en fonction de la lumière du jour (été ou hiver). Les termes UTC et GMT sont souvent utilisés de manière interchangeable pour exprimer les décalages, de sorte que UTC+2 et GMT+2 ont souvent la même signification.
Le décalage UTC est positif si le fuseau horaire est à l'est de GMT, et il est négatif si le fuseau horaire est à l'ouest de GMT.
Identificateurs de fuseaux horaires
//+------------------------------------------------------------------+ //| Identificateurs de fuseaux horaires| //+------------------------------------------------------------------+ enum ENUM_ZONE_ID { ZONE_ID_SYDNEY, // Sydney ZONE_ID_TOKYO, // Tokyo ZONE_ID_FRANKFURT, // Francfort ZONE_ID_LONDON, // Londres ZONE_ID_NEWYORK, // New York ZONE_ID_UTC, // UTC ZONE_ID_LOCAL, // LOCAL ZONE_ID_BROKER, // COURTIER ZONE_ID_CUSTOM // PERSONNALISÉ };
Interface de classe
//+------------------------------------------------------------------+ //| Classe CTimeZoneInfo.| //| Objet : Classe permettant d'accéder à l'heure locale pour l'heure spécifiée. //| Les informations relatives à l'emplacement, au fuseau horaire, à l'heure et à la date ne sont pas disponibles. //| changements pour l'année en cours.| //|| //| Notation de décalage utilisée dans la bibliothèque :| //| Veuillez noter que la bibliothèque indique un temps positif | //| Les zones par décalage positif, et les zones horaires négatives par décalage négatif. //| par des décalages négatifs.| //| Au contraire, la fonction intégrée TimeGMTOffset() de MQL5 | La fonction //| indique les fuseaux horaires positifs, comme GMT+3, | //| par des décalages négatifs, tels que -10800, et vice versa. //+------------------------------------------------------------------+ class CTimeZoneInfo { public: CTimeZoneInfo( ENUM_ZONE_ID placeId, datetime pLocalTime = TIME_NOW ); ~CTimeZoneInfo( void ); string Name( void ); // Retourne le nom du fuseau horaire string ToString( bool secs = true, bool tzname = true ); // Renvoie une chaîne de l'heure locale formatée avec le décalage TZ/DST et le nom tz. bool RefreshTime( void ); // Actualiser l'heure locale actuelle et renseigner les informations relatives au fuseau horaire bool SetLocalTime( datetime pLocalTime = TIME_NOW ); // Régler l'heure locale de ce lieu à l'heure spécifiée datetime TimeLocal( void ); // Renvoie l'heure locale dans le fuseau horaire datetime TimeUTC( void ); // Renvoie l'heure UTC (identique dans tous les fuseaux horaires) int TimeGMTOffset( void ); // Valeur positive pour les fuseaux horaires positifs (par exemple, GMT+3), sinon valeur négative. (y compris l'heure d'été) int TimeDaylightSavings( void ); // Renvoie la correction de l'heure d'été (en secondes) pour le fuseau horaire, à l'heure locale définie. datetime ConvertLocalTime( ENUM_ZONE_ID destinationId ); // Convertir l'heure locale de ce fuseau horaire vers un autre fuseau horaire bool GetDaylightSwitchTimes( datetime &dst_start, datetime &dst_end ); // Obtenir les heures de début et de fin de l'heure d'été pour l'année. datetime GetDaylightNextSwitch( void ); // Obtenir l'heure locale du prochain passage à l'heure d'été void PrintObject( void ); //--- les méthodes statiques qui ne nécessitent pas la création d'un objet. static datetime GetCurrentTimeForPlace ( ENUM_ZONE_ID placeId ); // Obtenir l'heure locale actuelle pour le fuseau horaire spécifié static string FormatTimeForPlace ( datetime time, ENUM_ZONE_ID placeId, bool secs = true, bool tzname = true ); static datetime ConvertTimeForPlace ( datetime time, ENUM_ZONE_ID placeId, ENUM_ZONE_ID destinationId ); static int TimeGMTOffset ( ENUM_ZONE_ID placeId, datetime time = TIME_NOW ); // Renvoie le décalage tz total (UTC+DST) par rapport à GMT, pour un fuseau horaire à une heure locale donnée. static int TimeDaylightSavings ( ENUM_ZONE_ID placeId, datetime time = TIME_NOW ); // Renvoie la correction dst en secondes, pour un fuseau horaire à l'heure locale donnée static bool IsDaylightSavingTime ( ENUM_ZONE_ID placeId, datetime time = TIME_NOW ); // Vérifie si l'heure spécifiée tombe dans l'heure d'été. static bool GetDaylightSwitchTimes ( ENUM_ZONE_ID placeId, int iYear, datetime &dst_start, datetime &dst_end ); static bool GetDaylightSwitchDeltas( ENUM_ZONE_ID placeId, int iYear, int &delta_start, int &delta_end ); static bool SetCustomTimeZone( string name, int baseGMTOffset = 0, // Définit un fuseau horaire qui n'existe pas dans la bibliothèque. ENUM_ZONE_ID dstSchedule = ZONE_ID_UTC ); static void SetUsingGoldSymbol( bool enabled = true ); // Définit l'option d'utilisation du symbole Gold pour l'estimation de l'heure d'été et d'hiver du serveur. };
Interface de classe
//+------------------------------------------------------------------+ //| Classe CSessionHours.| //| Objet : Classe permettant d'accéder aux heures d'ouverture de la session de négociation locale. //| l'emplacement spécifié.| //| Dérive de la classe CTimeZoneInfo.| //| Note : Les heures d'ouverture de la session sont définies par défaut entre 8h00 et 17h00. //| heure locale pour les nouveaux objets CSessionHours. | //+------------------------------------------------------------------+ class CSessionHours : public CTimeZoneInfo { public: CSessionHours( ENUM_ZONE_ID placeId ); ~CSessionHours( void ); //--- méthodes pour accéder à l'heure de la session locale bool RefreshTime( void ); // Actualiser l'heure locale et les heures de la session pour la journée. bool SetLocalTime( datetime pLocalTime ); //--- méthodes pour remplacer les heures de session locale par défaut bool BeginLocalTime( int pHour, int pMinute ); // Définir l'heure de début de la session locale en utilisant l'heure et les minutes de début. bool EndLocalTime( int pHour, int pMinute ); // Définir l'heure de fin de session locale en utilisant l'heure et les minutes de fin. //--- méthodes d'accès aux heures de session locales datetime BeginLocalTime( void ); datetime EndLocalTime( void ); bool CheckLocalSession( void ); // Vérifier si la session de négociation locale est actuellement active. int SecRemainingSession( void ); // Temps restant en secondes jusqu'à la fermeture de la session locale pour la journée. //--- les méthodes statiques qui ne nécessitent pas la création d'un objet. static datetime ForexCloseTime( void ); // L'heure de fermeture du marché Forex pour cette semaine. static int SecRemainingForex( void ); // Temps restant en secondes jusqu'à la fermeture du marché Forex pour cette semaine. };
Notation de décalage utilisée dans la bibliothèque
Veuillez noter que la bibliothèque désigne les fuseaux horaires positifs par des décalages positifs , et les fuseaux horaires négatifs par des décalages négatifs.
C'est le contraire de la fonction intégrée TimeGMTOffset() de MQL5 qui désigne les fuseaux horaires positifs, tels que GMT+3, par des décalages négatifs, tels que -10800, et vice versa.
Sélection du symbole pour l'estimation du serveur TZ/DST
Par défaut, la bibliothèque recherche et charge le symbole XAUUSD pour estimer le décalage du fuseau horaire du serveur. XAUUSD peut fournir des résultats plus fiables (en particulier pour les courtiers qui suivent l'horaire de l'heure d'été de l'Union européenne) les semaines où les horaires de l'heure d'été des États-Unis et de l'heure d'hiver de l'Union européenne ne sont pas synchronisés (mars et fin octobre). En option, si votre courtier suit l'horaire de l'heure d'été des États-Unis, ou pas d'horaire du tout, l'utilisation du symbole du graphique est également possible. Appelez CTimeZoneInfo::SetUsingGoldSymbol() avec 'false' pour utiliser le symbole du graphique actuel, au lieu de XAUUSD.
Pour déterminer l'horaire de jour (DST) de votre courtier, vous pouvez utiliser le script suivant : https://www.mql5.com/fr/code/48650
//+------------------------------------------------------------------+ //| Définit l'option d'utiliser le symbole XAUUSD (or) pour estimer la valeur de l'or. //| TZ/DST du serveur par analyse de l'historique des citations H1. | //| TRUE : recherche et chargement du symbole Gold (comportement par défaut). //| FALSE : utiliser le symbole du graphique en cours. //+------------------------------------------------------------------+ void CTimeZoneInfo::SetUsingGoldSymbol(const bool enabled = true);
Remarque:
Le fait que XAUUSD commence une heure après Forex a pour effet secondaire que les changements d'heure d'été se produiront une heure plus tard (uniquement dans le testeur de stratégie, et non dans le mode normal).
Note sur la compatibilité avec le testeur de stratégie
Pendant les tests dans le testeur de stratégie,TimeGMT() est toujours égal àTimeTradeServer() l'heure simulée du serveur.
La bibliothèque TimeZoneInfo estime les heures appropriées dans les fuseaux horaires sur la base du "vrai" GMT par l'analyse de l'historique des cotations H1, et non sur la base de l'heure renvoyée par l'appel à la fonction TimeGMT intégrée.
Si le symbole XAUUSD est utilisé pour estimer le TZ/DST du serveur, les changements de dst se produiront une heure plus tard dans le testeur de stratégie.
I. Travailler avec les fuseaux horaires locaux
Comment obtenir l'heure actuelle ?
La méthode RefreshTime()met à jour l'heure locale actuelle du fuseau horaire. Voyons un exemple pour montrer comment nous pouvons obtenir l'heure actuelle.
Print("\n========== Get the current time in a timezone =========="); CTimeZoneInfo tz(ZONE_ID_TOKYO); tz.RefreshTime(); // renseigner les informations sur le fuseau horaire actuel Print("Name() : ", tz.Name()); Print("TimeLocal() : ", tz.TimeLocal()); Print("ToString() : ", tz.ToString());
sortie:
// ========== Obtenir l'heure actuelle dans un fuseau horaire ========== // Nom() : Tokyo // TimeLocal() : 2024.02.28 19:58:50 // ToString() : Wed, 2024.02.28 19:58:50 GMT+9 [Tokyo]
Avez-vous besoin de plus d'informations ?
Print("\n========== More information about a timezone =========="); CTimeZoneInfo tz(ZONE_ID_NEWYORK); tz.RefreshTime(); Print("Name() : ", tz.Name()); Print("TimeUTC() : ", tz.TimeUTC()); Print("TimeLocal() : ", tz.TimeLocal()); Print("TimeGMTOffset() : ", tz.TimeGMTOffset()); Print("TimeDaylightSavings() : ", tz.TimeDaylightSavings()); Print("ToString() : ", tz.ToString()); datetime dst_start, dst_end; tz.GetDaylightSwitchTimes(dst_start, dst_end); Print("dst_start : ", dst_start); Print("dst_end : ", dst_end); Print("GetDaylightNextSwitch() : ", tz.GetDaylightNextSwitch());
output :
// ========== Plus d'informations sur un fuseau horaire ========== // Nom() : New York // TimeUTC() : 2024.03.17 16:50:38 // TimeLocal() : 2024.03.17 12:50:38 // TimeGMTOffset() : -14400 // TimeDaylightSavings() : 3600 // ToString() : Sun, 2024.03.17 12:50:38 GMT-4 [New York] (DST) // dst_start : 2024.03.10 02:00:00 // dst_end : 2024.11.03 02:00:00 // GetDaylightNextSwitch() : 2024.11.03 02:00:00
Notes :
- La méthode TimeUTC() renvoie l'heure UTC, qui est équivalente à l'heure GMT.
- La méthode TimeLocal() renvoie l'heure locale de ce fuseau horaire (qui a pu être modifiée à la suite de l'appel aux méthodes RefreshTime ou SetLocalTime ).
- La méthode TimeGMTOffset() renvoie la différence actuelle entre l'heure locale de ce fuseau horaire et l'heure GMT en secondes, en tenant compte du passage à l'heure d'hiver ou à l'heure d'été. Le décalage renvoyé inclut l'ajustement de l'heure d'été ou d'hiver du fuseau horaire actuel. Le décalage GMT est positif si le fuseau horaire est à l'est de (en avance sur) GMT, et il est négatif si le fuseau horaire est à l'ouest de (en retard sur) GMT.
- La méthode TimeDaylightSavings() renvoie l'ajustement à l'heure d'été (DST) en secondes, si le passage à l'heure d'été a été effectué dans les zones où le DST est en vigueur. Si le passage à l'heure d'hiver (standard) a été effectué (ou si le fuseau horaire ne supporte pas l'heure d'été), elle renvoie 0. L'ajustement de l'heure d'été fait déjà partie du décalage TimeGMTOffset.
Comment configurer le fuseau horaire personnalisé intégré pour une utilisation ultérieure ?
La classe CTimeZoneInfo comprend une méthode SetCustomTimeZone , que vous pouvez utiliser pour configurer le fuseau horaire personnalisé intégré. Par la suite, le fuseau horaire personnalisé peut être utilisé via l'identifiant ZONE_ID_CUSTOM. Voyons un exemple pour montrer comment nous pouvons configurer le fuseau horaire personnalisé intégré avec un nom spécifié, un décalage par rapport au Greenwich Mean Time (GMT) et un identifiant d'horaire de jour.
Print("\n========== Configure the built-in custom timezone =========="); string name = "Custom+3"; // Nom du fuseau horaire personnalisé int baseGMTOffset = 10800; // Décalage GMT de base du fuseau horaire personnalisé (en secondes) ENUM_ZONE_ID daylightRuleId = ZONE_ID_LONDON; // Horaire du fuseau horaire personnalisé bool success = CTimeZoneInfo::SetCustomTimeZone(name, baseGMTOffset, daylightRuleId); Print("Parameter 'name' : ", name); Print("Parameter 'baseGMTOffset' : ", baseGMTOffset); Print("Parameter 'daylightRuleId' : ", EnumToString(daylightRuleId)); Print("SetCustomTimeZone() returns : ", success);
Sortie :
// ========== Configurer le fuseau horaire personnalisé intégré ========== // Paramètre 'name' : Personnalisé+3 // Paramètre 'baseGMTOffset' : 10800 // Paramètre 'daylightRuleId' : ZONE_ID_LONDON // SetCustomTimeZone() renvoie : true
Obtenir l'heure actuelle dans tous les fuseaux horaires
Voyons un exemple qui montre comment nous pouvons obtenir l'heure locale actuelle dans tous les fuseaux horaires.
Print("\n========== Get Current Time in All Timezones =========="); for(ENUM_ZONE_ID id=0; id <= MAX_ZONE_ID; id++) { CTimeZoneInfo tz(id); tz.RefreshTime(); PrintFormat("%-12s: %s | %s", tz.Name(), TimeToString(tz.TimeLocal()), tz.ToString()); }
sortie :
// ========== Obtenir l'heure actuelle dans tous les fuseaux horaires ========== // Sydney : 2024.02.28 21:58 | Wed, 2024.02.28 21:58:50 GMT+11 [Sydney] (DST) // Tokyo : 2024.02.28 19:58 | Wed, 2024.02.28 19:58:50 GMT+9 [Tokyo] // Francfort : 2024.02.28 11:58 | Wed, 2024.02.28 11:58:50 GMT+1 [Francfort] // Londres : 2024.02.28 10:58 | Wed, 2024.02.28 10:58:50 GMT+0 [Londres] // New York : 2024.02.28 05:58 | Wed, 2024.02.28 05:58:50 GMT-5 [New York] // UTC : 2024.02.28 10:58 | Wed, 2024.02.28 10:58:50 GMT+0 [UTC] // Accueil : 2024.02.28 12:58 | Wed, 2024.02.28 12:58:50 GMT+2 [Accueil] // FXOpen-MT5 : 2024.02.28 12:58 | Wed, 2024.02.28 12:58:50 GMT+2 [FXOpen-MT5]
Cette opération peut être réalisée d'une autre manière en utilisant la méthode statique GetCurrentTimeForPlace(). Notez également qu'il existe une autre méthode statique FormatTimeForPlace() qui peut être utilisée pour formater des variables mql datetime simples en une chaîne ( similaire à TimeToString) mais avec le jour de la semaine, la date, l'heure, le nom du fuseau horaire et les décalages. Ces méthodes statiques ne nécessitent pas la création d'objets pour être appelées.
Print("\n========== GetCurrentTimeForPlace() =========="); for(ENUM_ZONE_ID id=0; id <= MAX_ZONE_ID; id++) { datetime time = CTimeZoneInfo::GetCurrentTimeForPlace(id); PrintFormat("Time : %s | %s", TimeToString(time), CTimeZoneInfo::FormatTimeForPlace(time, id)); }
sortie:
// ========== GetCurrentTimeForPlace() ========== // Heure : 2024.02.28 21:58 | Wed, 2024.02.28 21:58:50 GMT+11 [Sydney] (DST) // Heure : 2024.02.28 19:58 | Wed, 2024.02.28 19:58:50 GMT+9 [Tokyo] // Heure : 2024.02.28 11:58 | Wed, 2024.02.28 11:58:50 GMT+1 [Frankfurt] // Heure : 2024.02.28 10:58 | Wed, 2024.02.28 10:58:50 GMT+0 [London] // Heure : 2024.02.28 05:58 | Wed, 2024.02.28 05:58:50 GMT-5 [New York] // Heure : 2024.02.28 10:58 | Wed, 2024.02.28 10:58:50 GMT+0 [UTC] // Heure : 2024.02.28 12:58 | Wed, 2024.02.28 12:58:50 GMT+2 [Accueil]. // Heure : 2024.02.28 12:58 | Wed, 2024.02.28 12:58:50 GMT+2 [FXOpen-MT5]
Comment définir l'heure locale pour le fuseau horaire ?
La méthode SetLocalTime()permet de régler l'heure locale spécifiée. Voyons un exemple pour montrer comment nous pouvons régler l'heure locale pour le fuseau horaire.
Print("\n========== Set the local time for a timezone =========="); CTimeZoneInfo tz(ZONE_ID_NEWYORK); if(tz.SetLocalTime(D'2021.07.15 09:31')) PrintFormat("%-12s: %s | %s", tz.Name(), TimeToString(tz.TimeLocal()), tz.ToString()); if(tz.SetLocalTime(D'2022.01.23 17:04')) PrintFormat("%-12s: %s | %s", tz.Name(), TimeToString(tz.TimeLocal()), tz.ToString()); if(tz.SetLocalTime(D'2023.03.12 02:21')) PrintFormat("%-12s: %s | %s", tz.Name(), TimeToString(tz.TimeLocal()), tz.ToString());
La méthode SetLocalTime() permet de régler l'heure locale pour le fuseau horaire :
// ========== Fixer l'heure locale pour un fuseau horaire ========== // New York : 2021.07.15 09:31 | Thu, 2021.07.15 09:31:00 GMT-4 [New York] (DST) // New York : 2022.01.23 17:04 | Sun, 2022.01.23 17:04:00 GMT-5 [New York] // >>Erreur : L'heure 2023.03.12 02:21 n'existe pas à New York. Cela est dû au fait que l'heure d'été a sauté une heure.
La cause du dernier message d'erreur que nous obtenons sera expliquée dans le paragraphe suivant.
L'heure d'été (DST) :
L'heure d'été est une mesure de changement d'heure saisonnier qui consiste à avancer les horloges par rapport à l'heure normale pendant une partie de l'année.
Voir https://www.timeanddate.com/time/dst/transition.html
("Saut d'été", "Retour d'hiver")
Lorsque l'heure d'été commence au printemps, nos horloges sont avancées d'un certain temps, généralement d'une heure. Cela signifie qu'une heure est sautée sur l'horloge. À l'automne, la période d'heure avancée se termine généralement et nos horloges reviennent à l'heure normale.
Exemple de début d'heure avancée
(l'heure inexistante)
Aux États-Unis, l'heure d'été commence toujours à 02:00 (2 heures du matin), heure locale. Au moment où l'heure atteint pour la première fois 1:59:59 heure normale, les horloges avancent à 3:00:00 heure d'été. Ainsi, l'heure de 2:00:00 à 2:59:59 n'existe pas dans la nuit du passage à l'heure d'été.
II. Obtenir des informations sur le fuseau horaire
1. Décalage UTC et décalage DST actuel
Voyons un exemple qui montre comment nous pouvons obtenir le nom du fuseau horaire, le décalage UTC et le décalage DST actuel si le DST est en vigueur.
Print("\n========== UTC offset and current DST offset =========="); for(ENUM_ZONE_ID id=0; id <= MAX_ZONE_ID; id++) { CTimeZoneInfo tz(id); tz.RefreshTime(); // renseigner les informations sur le fuseau horaire actuel PrintFormat("%-12s: GMT%+g | DST%+g", tz.Name(), tz.TimeGMTOffset()/3600., tz.TimeDaylightSavings()/3600.); }
sortie :
// ========== décalage UTC et décalage DST actuel ========== // Sydney : GMT+11 | DST+1 // Tokyo : GMT+9 | DST+0 // Francfort : GMT+1 | DST+0 // Londres : GMT+0 | DST+0 // New York : GMT-4 | DST+1 // UTC : GMT+0 | DST+0 // Accueil : GMT+2 | DST+0 // FXOpen-MT5 : GMT+2 | DST+0
Notes :
- La méthode TimeGMTOffset() renvoie la différence actuelle entre l'heure locale de ce fuseau horaire et l'heure GMT en secondes, en tenant compte du passage à l'heure d'hiver ou à l'heure d'été. Le décalage renvoyé inclut l'ajustement DST du fuseau horaire actuel. Le décalage GMT est positif si le fuseau horaire est à l'est de (en avance sur) GMT, et il est négatif si le fuseau horaire est à l'ouest de (en retard sur) GMT.
- La méthode TimeDaylightSavings() renvoie l'ajustement à l'heure d'été (DST) en secondes, si le passage à l'heure d'été a été effectué dans les zones où le DST est en vigueur. Si le passage à l'heure d'hiver (standard) a été effectué (ou si le fuseau horaire ne supporte pas l'heure d'été), elle renvoie 0. L'ajustement de l'heure d'été fait déjà partie du décalage TimeGMTOffset.
2. Heures de passage à l'heure d'été pour l'année en cours
Voyons un exemple qui montre comment nous pouvons obtenir les informations sur l'heure d'été et l'heure d'hiver.
Print("\n========== DST switch times for the current year =========="); datetime dst_start, dst_end; for(ENUM_ZONE_ID id=0; id <= MAX_ZONE_ID; id++) { CTimeZoneInfo tz(id); tz.RefreshTime(); // renseigner les informations sur le fuseau horaire actuel //--- uniquement pour les fuseaux horaires qui observent l'heure d'été. if(tz.GetDaylightSwitchTimes(dst_start, dst_end)) { PrintFormat("%-12s: DST starts on %s | DST ends on %s", tz.Name(), TimeToString(dst_start), TimeToString(dst_end)); } }
sortie :
// ========== Heures de passage à l'heure d'été pour l'année en cours ========== // Sydney : L'heure d'été commence le 2024.04.07 03:00 | L'heure d'été se termine le 2024.10.06 02:00 // Francfort : l'heure d'été commence le 2024.03.31 02:00 | l'heure d'été se termine le 2024.10.27 03:00 // Londres : l'heure d'été commence le 2024.03.31 01:00 | l'heure d'été se termine le 2024.10.27 02:00 // New York : L'heure d'été commence le 2024.03.10 02:00 | L'heure d'été se termine le 2024.11.03 02:00
3. Heure du prochain passage à l'heure d'été
Voyons un exemple qui montre comment nous pouvons obtenir l'heure du prochain passage à l'heure d'été.
Print("\n========== Time of the next DST switch =========="); for(ENUM_ZONE_ID id=0; id <= MAX_ZONE_ID; id++) { CTimeZoneInfo tz(id); tz.RefreshTime(); datetime nxswitch = tz.GetDaylightNextSwitch(); //--- uniquement pour les fuseaux horaires qui observent l'heure d'été. if(nxswitch) { PrintFormat("%-12s: Time: %s | dstNextSwitch: %s", tz.Name(), TimeToString(tz.TimeLocal()), TimeToString(nxswitch)); } }
sortie :
// ========== Heure du prochain changement d'heure d'été ========== // Sydney : Heure : 2024.02.28 21:58 | dstNextSwitch : 2024.04.07 03:00 // Francfort : Heure : 2024.02.28 11:58 | dstNextSwitch : 2024.03.31 02:00 // Londres : Heure : 2024.02.28 10:58 | dstNextSwitch : 2024.03.31 01:00 // New York : Heure : 2024.02.28 05:58 | dstNextSwitch : 2024.03.10 02:00
4. Liste des heures d'été
Voyons un exemple qui montre comment nous pouvons obtenir les informations sur l'heure d'été pour tous les fuseaux horaires de cette bibliothèque pour une série d'années.
Print("\n========== DST List =========="); datetime dst_start, dst_end; int delta_start, delta_end; // l'horloge change en secondes for(ENUM_ZONE_ID id=0; id <= MAX_ZONE_ID; id++) { CTimeZoneInfo timezone(id); PrintFormat("========= %s Summer Time (DST) =========", timezone.Name()); for(int year=2008; year<=2030; year++) { //--- uniquement pour les fuseaux horaires qui observent l'heure d'été. if(CTimeZoneInfo::GetDaylightSwitchTimes(id, year, dst_start, dst_end)) { CTimeZoneInfo::GetDaylightSwitchDeltas(id, year, delta_start, delta_end); PrintFormat("DST starts on %s (%+d) and ends on %s (%+d)",TimeToString(dst_start), delta_start/3600, TimeToString(dst_end), delta_end/3600); } } }
sortie :
// ========== Liste DST ========== // ========= Heure d'été de Sydney (DST) ========= // L'heure d'été commence le 2008.04.06 03:00 (-1) et se termine le 2008.10.05 02:00 (+1) // L'heure d'été commence le 2009.04.05 03:00 (-1) et se termine le 2009.10.04 02:00 (+1) // L'heure d'été commence le 2010.04.04 03:00 (-1) et se termine le 2010.10.03 02:00 (+1) // L'heure d'été commence le 2011.04.03 03:00 (-1) et se termine le 2011.10.02 02:00 (+1) // L'heure d'été commence le 2012.04.01 03:00 (-1) et se termine le 2012.10.07 02:00 (+1) // ... // ... // ...
5. Décalage GMT du serveur (actuel)
Le décalage GMT du courtier indique de combien de secondes l'heure du courtier est en avance sur l'heure GMT, décalage du courtier = TimeTradeServer() - TimeGMT(). Des valeurs positives indiquent que l'heure du serveur est en avance sur l'heure GMT. Voyons un exemple pour montrer comment nous pouvons obtenir le décalage GMT actuel du courtier.
Print("\n========== Current GMT offset of the broker ========== "); CTimeZoneInfo broker(ZONE_ID_BROKER); broker.RefreshTime(); Print("Name() : ", broker.Name()); Print("TimeLocal() : ", broker.TimeLocal()); // temps du courtier Print("ToString() : ", broker.ToString()); Print("TimeGMTOffset() : ", broker.TimeGMTOffset());
sortie :
// ========== Décalage GMT actuel du courtier ========== // Name() : ICMarketsSC-Demo // TimeLocal() : 2024.03.08 06:33:06 // ToString() : Fri, 2024.03.08 06:33:06 GMT+2 [ICMarketsSC-Demo] // TimeGMTOffset() : 7200
Note : Une note importante pour TimeGMTOffset() est qu'il retournera le décalage utc incluant la correction dst (UTC+DST). Des valeurs positives indiquent que l'heure du serveur est en avance (à l'est) par rapport à GMT.
6. Décalage GMT du serveur (historique)
Les décalages GMT passés du serveur peuvent être calculés comme la différence entre l'heure d'apparition de la première barre de la semaine du serveur sur le graphique, et l'heure UTC correspondant au dimanche 17 heures, heure de New York. Voyons un exemple pour montrer comment nous pouvons obtenir les décalages GMT passés du courtier. Pour cet exemple, nous utiliserons les heures des bougies du graphique comme heure passée du courtier.
Print("\n========== Past GMT offsets of the broker (chart candles) =========="); datetime bartimes[]; int copied = CopyTime(Symbol(), PERIOD_D1, D'2022.03.18', 9, bartimes); if(copied<=0) Print("CopyTime() failed."); for(int i =0; i < copied; i++) { datetime t = bartimes[i]; CTimeZoneInfo broker(ZONE_ID_BROKER); broker.SetLocalTime(t); PrintFormat("bar #%i Time: %s | offset: %5d (GMT%+g) | %s", i+1, TimeToString(broker.TimeLocal()), broker.TimeGMTOffset(), broker.TimeGMTOffset()/3600.0, broker.ToString()); }
Sortie :
// ========== Décalages GMT passés du courtier (bougies graphiques) ========== // barre #1 Time : 2022.03.08 00:00 | offset : 7200 (GMT+2) | Tue, 2022.03.08 00:00:00 GMT+2 [ICMarketsSC-Demo] // barre #2 Time : 2022.03.09 00:00 | offset : 7200 (GMT+2) | Wed, 2022.03.09 00:00:00 GMT+2 [ICMarketsSC-Demo] // barre #3 Time : 2022.03.10 00:00 | offset : 7200 (GMT+2) | Thu, 2022.03.10 00:00:00 GMT+2 [ICMarketsSC-Demo] // barre #4 Time : 2022.03.11 00:00 | offset : 7200 (GMT+2) | Fri, 2022.03.11 00:00:00 GMT+2 [ICMarketsSC-Demo] // barre #5 Time : 2022.03.14 00:00 | offset : 10800 (GMT+3) | Mon, 2022.03.14 00:00:00 GMT+3 [ICMarketsSC-Demo] // barre #6 Time : 2022.03.15 00:00 | offset : 10800 (GMT+3) | Tue, 2022.03.15 00:00:00 GMT+3 [ICMarketsSC-Demo] // bar #7 Time : 2022.03.16 00:00 | offset : 10800 (GMT+3) | Wed, 2022.03.16 00:00:00 GMT+3 [ICMarketsSC-Demo] // barre #8 Time : 2022.03.17 00:00 | offset : 10800 (GMT+3) | Thu, 2022.03.17 00:00:00 GMT+3 [ICMarketsSC-Demo] // bar #9 Time : 2022.03.18 00:00 | offset : 10800 (GMT+3) | Fri, 2022.03.18 00:00:00 GMT+3 [ICMarketsSC-Demo]
Comme vous le voyez dans la barre #5, le serveur est passé de +2 heure d'hiver à +3 heure d'été, et l'heure du changement suit l'horaire DST des Etats-Unis (2ème dimanche de mars). Il y a cinq bougies D1 par semaine, et pas de bougies le samedi et le dimanche. L 'heure sur ces serveurs est toujours en avance de 7 heures sur New York tout au long de l'année et est représentée par NY+7. Notez que NY est à -5 en hiver, et à -4 en été.
Il s'agit de la première bibliothèque de la base de code capable de déterminer le décalage GMT du serveur dans le passé (décalage GMT historique). L'algorithme mis en œuvre dans les calculs est très rapide et précis, et il est compatible - dans la mesure du possible - avec différents courtiers (testé sur un grand nombre de courtiers avec différents décalages GMT ou horaires DST).
III. Conversion entre fuseaux horaires
Convertir l'heure locale actuelle vers un autre fuseau horaire
Utilisez la méthode ConvertLocalTime() pour convertir l'heure locale de cette instance de fuseau horaire dans un fuseau horaire spécifique. Cette méthode renvoie la nouvelle heure d'un fuseau horaire donné.
Voyons un exemple pour montrer comment nous pouvons convertir l'heure locale"actuelle" en un fuseau horaire spécifique.
Print("\n========== Convert current local time in Sydney to New York =========="); CTimeZoneInfo sydney(ZONE_ID_SYDNEY); sydney.RefreshTime(); datetime localtime = sydney.TimeLocal(); datetime converted = sydney.ConvertLocalTime(ZONE_ID_NEWYORK); PrintFormat("%s | %s", TimeToString(localtime), sydney.ToString()); PrintFormat("%s | %s", TimeToString(converted), CTimeZoneInfo::FormatTimeForPlace(converted, ZONE_ID_NEWYORK));
sortie :
// ========== Convertir l'heure locale de Sydney en heure de New York ========== // 2024.02.28 21:58 | Wed, 2024.02.28 21:58:50 GMT+11 [Sydney] (DST) // 2024.02.28 05:58 | Wed, 2024.02.28 05:58:50 GMT-5 [New York]
Convertir une heure locale spécifique en un autre fuseau horaire
Voyons un exemple pour montrer comment nous pouvons convertir une heure locale spécifique vers un fuseau horaire spécifique.
Print("\n========== Convert a specific local time in Sydney to New York =========="); CTimeZoneInfo sydney(ZONE_ID_SYDNEY); sydney.SetLocalTime(D'2016.05.21 14:47:08'); datetime localtime = sydney.TimeLocal(); datetime converted = sydney.ConvertLocalTime(ZONE_ID_NEWYORK); PrintFormat("%s | %s", TimeToString(localtime), sydney.ToString()); PrintFormat("%s | %s", TimeToString(converted), CTimeZoneInfo::FormatTimeForPlace(converted, ZONE_ID_NEWYORK));
output :
// ========== Convertir l'heure locale de Sydney en heure locale de New York ========== // 2016.05.21 14:47 | Sat, 2016.05.21 14:47:08 GMT+10 [Sydney] // 2016.05.21 00:47 | Sat, 2016.05.21 00:47:08 GMT-4 [New York] (DST)
Conversion de l'heure locale actuelle dans tous les fuseaux horaires vers l'heure du courtier
Voyons un exemple qui montre comment nous pouvons convertir l'heure locale actuelle dans tous les fuseaux horaires à l'heure du courtier.
Print("\n========== Convert the current local time in all timezones to the broker time =========="); for(ENUM_ZONE_ID id=0; id <= MAX_ZONE_ID; id++) { datetime localtime = CTimeZoneInfo::GetCurrentTimeForPlace(id); datetime converted = CTimeZoneInfo::ConvertTimeForPlace(localtime, id, ZONE_ID_BROKER); PrintFormat("%-49s | %s", CTimeZoneInfo::FormatTimeForPlace(localtime, id), CTimeZoneInfo::FormatTimeForPlace(converted, ZONE_ID_BROKER)); }
sortie :
// ========== Convertir l'heure locale actuelle dans tous les fuseaux horaires en heure du courtier ========== // Wed, 2024.02.28 21:58:50 GMT+11 [Sydney] (DST) | Wed, 2024.02.28 12:58:50 GMT+2 [FXOpen-MT5] // Wed, 2024.02.28 19:58:50 GMT+9 [Tokyo] | Wed, 2024.02.28 12:58:50 GMT+2 [FXOpen-MT5] // Wed, 2024.02.28 11:58:50 GMT+1 [Frankfurt] | Wed, 2024.02.28 12:58:50 GMT+2 [FXOpen-MT5] // Wed, 2024.02.28 10:58:50 GMT+0 [London] | Wed, 2024.02.28 12:58:50 GMT+2 [FXOpen-MT5] // Wed, 2024.02.28 05:58:50 GMT-5 [New York] | Wed, 2024.02.28 12:58:50 GMT+2 [FXOpen-MT5] // Wed, 2024.02.28 10:58:50 GMT+0 [UTC] | Wed, 2024.02.28 12:58:50 GMT+2 [FXOpen-MT5] // Wed, 2024.02.28 12:58:50 GMT+2 [Home] | Wed, 2024.02.28 12:58:50 GMT+2 [FXOpen-MT5] // Wed, 2024.02.28 12:58:50 GMT+2 [FXOpen-MT5] | Wed, 2024.02.28 12:58:50 GMT+2 [FXOpen-MT5]
IV. Utilisation des heures de session locales
A. Classe CTimeZoneInfo
Notez que l'utilisation de la classe mère CTimeZoneInfo , plutôt que la classe CSessionHours , n'est pas préférable car elle nécessite plus de codage et est donc sujette à des erreurs. Voyons un exemple pour montrer comment nous obtenons les heures de la séance Forex dans tous les fuseaux horaires, et comment nous les convertissons à l'heure du courtier.
Print("\n======= Local Session Hours (CTimeZoneInfo Class) ======="); const ENUM_ZONE_ID ids[] = {ZONE_ID_SYDNEY, ZONE_ID_TOKYO, ZONE_ID_FRANKFURT, ZONE_ID_LONDON, ZONE_ID_NEWYORK}; for(int i = 0; i < ArraySize(ids); i++) { ENUM_ZONE_ID id = ids[i]; CTimeZoneInfo tz(id); tz.RefreshTime(); datetime localtime = tz.TimeLocal(); //--- fixer les heures de session à 8h00 - 17h00 (heure locale) datetime beginlocal = StringToTime(TimeToString(localtime, TIME_DATE) + " " + "08:00"); datetime endlocal = StringToTime(TimeToString(localtime, TIME_DATE) + " " + "17:00"); //--- conversion en heure du courtier tz.SetLocalTime(beginlocal); datetime beginbroker = tz.ConvertLocalTime(ZONE_ID_BROKER); tz.SetLocalTime(endlocal); datetime endbroker = tz.ConvertLocalTime(ZONE_ID_BROKER); //--- jour local de la semaine dans le fuseau horaire MqlDateTime st; TimeToStruct(localtime, st); int dow = st.day_of_week; //string state_str = ((dow != SATURDAY && dow != SUNDAY) && (localtime >= beginlocal && localtime < endlocal)) ? "ouvert" : "fermé" ; string state_str = ((dow != SATURDAY && dow != SUNDAY) && (TimeTradeServer() >= beginbroker && TimeTradeServer() < endbroker)) ? "open" : "closed"; PrintFormat("%-12s: %s | %s [session %s]", tz.Name(), CTimeZoneInfo::FormatTimeForPlace(beginbroker, ZONE_ID_BROKER), CTimeZoneInfo::FormatTimeForPlace(endbroker, ZONE_ID_BROKER), state_str); } Print("-----------------------------------"); Print("broker time : ", TimeTradeServer()); Print("broker time : ", CTimeZoneInfo::FormatTimeForPlace(TimeTradeServer(), ZONE_ID_BROKER));
sortie :
// ======= Heures de la session locale (classe CTimeZoneInfo) ======= // Sydney : Wed, 2024.02.28 23:00:00 GMT+2 [FXOpen-MT5] | Thu, 2024.02.29 08:00:00 GMT+2 [FXOpen-MT5] [session close] // Tokyo : Wed, 2024.02.28 01:00:00 GMT+2 [FXOpen-MT5] | Wed, 2024.02.28 10:00:00 GMT+2 [FXOpen-MT5] [session close] // Francfort : Wed, 2024.02.28 09:00:00 GMT+2 [FXOpen-MT5] | Wed, 2024.02.28 18:00:00 GMT+2 [FXOpen-MT5] [session ouverte] // Londres : Wed, 2024.02.28 10:00:00 GMT+2 [FXOpen-MT5] | Wed, 2024.02.28 19:00:00 GMT+2 [FXOpen-MT5] [session ouverte] // New York : Wed, 2024.02.28 15:00:00 GMT+2 [FXOpen-MT5] | Thu, 2024.02.29 00:00:00 GMT+2 [FXOpen-MT5] [session ouverte] // ----------------------------------- // broker time : 2024.02.28 15:32:30 // broker time : Wed, 2024.02.28 15:32:30 GMT+2 [FXOpen-MT5]
B. Classe CSessionHours
Objectif: Classe permettant d'accéder aux heures de la séance de négociation locale pour l'emplacement spécifié.
Dérivée de la classe CTimeZoneInfo.
Remarque: Les heures d'ouverture par défaut sont fixées à 8h00 - 17h00, heure locale, pour les nouveaux objets CSessionHours . Ces valeurs par défaut peuvent être modifiées à volonté.
Utilisation des objets CSessionHours
Voyons un exemple d'utilisation de l'objet.
Print("\n========== Working with CSessionHours Objects =========="); CSessionHours tz(ZONE_ID_SYDNEY); tz.RefreshTime(); // renseigner le fuseau horaire et les informations relatives à la session //--- du parent Print("Name() : ", tz.Name()); Print("TimeUTC() : ", tz.TimeUTC()); Print("TimeLocal() : ", tz.TimeLocal()); Print("ToString() : ", tz.ToString()); //--- de la classe Print("BeginLocalTime() : ", tz.BeginLocalTime()); Print("EndLocalTime() : ", tz.EndLocalTime()); Print("CheckLocalSession() : ", tz.CheckLocalSession()); Print("SecRemainingSession() : ", tz.SecRemainingSession()); Print("SecondsToString() : ", CSessionHours::SecondsToString(tz.SecRemainingSession()));
sortie :
// ========== Travailler avec des objets CSessionHours ========== // Name() : Sydney // TimeUTC() : 2024.02.28 10:58:50 // TimeLocal() : 2024.02.28 21:58:50 // ToString() : Wed, 2024.02.28 21:58:50 GMT+11 [Sydney] (DST) // BeginLocalTime() : 2024.02.28 08:00:00 // EndLocalTime() : 2024.02.28 17:00:00 // CheckLocalSession() : false // SecRemainingSession() : 0 // SecondsToString() : 00:00:00
Local Session Hours
L'objet CSessionHours offre plus de fonctionnalités avec moins de code. Voyons un exemple qui montre comment nous obtenons les heures de session du Forex dans tous les fuseaux horaires à l'aide de la classe CSessionHours , et comment nous les convertissons à l'heure du courtier. Notez que la conversion à l'heure du courtier est une étape facultative, et qu'elle n'est pas nécessaire pour vérifier les heures de début et de fin de chaque session.
Print("\n======= Local Session Hours (CSessionHours Class) ======="); const ENUM_ZONE_ID ids[] = {ZONE_ID_SYDNEY, ZONE_ID_TOKYO, ZONE_ID_FRANKFURT, ZONE_ID_LONDON, ZONE_ID_NEWYORK}; for(int i = 0; i < ArraySize(ids); i++) { ENUM_ZONE_ID id = ids[i]; CSessionHours tz(id); tz.RefreshTime(); //--- les heures de session par défaut sont fixées à 8h00 - 17h00 (heure locale) datetime beginlocal = tz.BeginLocalTime(); datetime endlocal = tz.EndLocalTime(); //--- conversion en heure du courtier datetime beginbroker = CTimeZoneInfo::ConvertTimeForPlace(beginlocal, id, ZONE_ID_BROKER); datetime endbroker = CTimeZoneInfo::ConvertTimeForPlace(endlocal, id, ZONE_ID_BROKER); string state_str = tz.CheckLocalSession() ? "open, ends in " + CSessionHours::SecondsToString(tz.SecRemainingSession()) : "closed"; PrintFormat("%-12s: %s | %s [session %s]", tz.Name(), CTimeZoneInfo::FormatTimeForPlace(beginbroker, ZONE_ID_BROKER), CTimeZoneInfo::FormatTimeForPlace(endbroker, ZONE_ID_BROKER), state_str); } Print("-----------------------------------"); Print("broker time : ", TimeTradeServer()); Print("broker time : ", CTimeZoneInfo::FormatTimeForPlace(TimeTradeServer(), ZONE_ID_BROKER)); Print("Fx close : ", CTimeZoneInfo::FormatTimeForPlace(CSessionHours::ForexCloseTime(), ZONE_ID_BROKER)); int sec = CSessionHours::SecRemainingForex(); Print("closes in : ", sec, " sec = ", CSessionHours::SecondsToString(sec));
sortie :
// ======= Heures de la session locale (classe CSessionHours) ======= // Sydney : Wed, 2024.02.28 23:00:00 GMT+2 [FXOpen-MT5] | Thu, 2024.02.29 08:00:00 GMT+2 [FXOpen-MT5] [session close] // Tokyo : Wed, 2024.02.28 01:00:00 GMT+2 [FXOpen-MT5] | Wed, 2024.02.28 10:00:00 GMT+2 [FXOpen-MT5] [session close] // Francfort : Wed, 2024.02.28 09:00:00 GMT+2 [FXOpen-MT5] | Wed, 2024.02.28 18:00:00 GMT+2 [FXOpen-MT5] [session ouverte, fin dans 02:27:29]. // Londres : Wed, 2024.02.28 10:00:00 GMT+2 [FXOpen-MT5] | Wed, 2024.02.28 19:00:00 GMT+2 [FXOpen-MT5] [session ouverte, fin dans 03:27:29] // New York : Wed, 2024.02.28 15:00:00 GMT+2 [FXOpen-MT5] | Thu, 2024.02.29 00:00:00 GMT+2 [FXOpen-MT5] [session ouverte, fin dans 08:27:29]. // ----------------------------------- // broker time : 2024.02.28 15:32:30 // broker time : Wed, 2024.02.28 15:32:30 GMT+2 [FXOpen-MT5] // Clôture Fx : Sat, 2024.03.02 00:00:00 GMT+2 [FXOpen-MT5] // clôture en : 203249 sec = 2d 08:27:29
Comment remplacer les heures de session locales par défaut ?
Voyons un exemple pour montrer comment nous pouvons remplacer les heures de session par défaut dans la classe CSessionHours .
Print("\n=========== Override the default session hours ==========="); CSessionHours frankfurt(ZONE_ID_FRANKFURT); // modifier les heures de session par défaut frankfurt.BeginLocalTime(9, 0); frankfurt.EndLocalTime(19, 0); frankfurt.RefreshTime(); // alimenter les heures de la nouvelle session datetime beginlocal = frankfurt.BeginLocalTime(); datetime endlocal = frankfurt.EndLocalTime(); PrintFormat("new session hours : %s | %s", CTimeZoneInfo::FormatTimeForPlace(beginlocal, ZONE_ID_FRANKFURT), CTimeZoneInfo::FormatTimeForPlace(endlocal, ZONE_ID_FRANKFURT)); PrintFormat("current local time : %s", frankfurt.ToString());
output :
// =========== Remplacer les heures de session par défaut =========== // nouvelles heures de session : Wed, 2024.02.28 09:00:00 GMT+1 [Frankfurt] | Wed, 2024.02.28 19:00:00 GMT+1 [Frankfurt] // heure locale actuelle : Wed, 2024.02.28 11:58:50 GMT+1 [Frankfurt]
Comment vérifier les positions de clôture en fin de semaine ?
La méthode statique SecRemainingForex() renvoie le temps restant en secondes jusqu'à la fermeture du marché du Forex pour cette semaine. Cette méthode doit être appelée à partir du gestionnaire d'événement OnTick()(ou mieux à partir de OnTimer() dans le cas où aucun tic n'arrive juste avant le week-end) pour vérifier de manière répétée la condition de clôture. Voyons un exemple pour montrer comment nous pouvons vérifier les positions de clôture pendant le week-end.
Print("\n======= Check For Closing Positions at Weekend ======="); int InpHours = 2; // Heures avant le week-end int InpMinutes = 30; // Minutes avant le week-end int sec = CSessionHours::SecRemainingForex(); PrintFormat("Time remaining till the weekend : %s", CSessionHours::SecondsToString(sec)); PrintFormat("Close all if remaining time becomes %s or less.", CSessionHours::SecondsToString(InpHours * 3600 + InpMinutes * 60)); // vérifier que le temps restant a atteint l'objectif if(sec <= InpHours * 3600 + InpMinutes * 60) { // CloseAll() ; }
Il est également possible de vérifier la condition précédente en utilisant des heures absolues :
// vérifier que le temps du courtier a atteint l'objectif if(TimeTradeServer() >= CSessionHours::ForexCloseTime() - (InpHours * 3600 + InpMinutes * 60)) { // CloseAll() ; }
sortie :
// ======= Check For Closing Positions at Weekend ======= // Temps restant jusqu'au week-end : 3d 03:32:27 // Fermer tout si le temps restant est de 02:30:00 ou moins.
Fin de la semaine - Fuseau horaire du courtier et horaire DST
Le marché des changes ouvre le dimanche à 17 heures, heure de New York (GMT-5 en hiver et GMT-4 en été) et ferme le vendredi à la même heure. L'heure d'ouverture à New York correspond au dimanche, 22 heures UTC en hiver (et au dimanche, 21 heures UTC en été). Le marché des changes ferme le vendredi à 22h00 UTC en hiver (et à 21h00 UTC en été). Le marché au comptant de l'or et de l'argent démarre généralement une heure plus tard. lien
Chaque courtier en devises a son propre fuseau horaire et son propre serveur. Par conséquent, le début de la semaine de négociation (bougies H1) varie d'un courtier à l'autre, et peut aller dedimanche, 02:00 PM heure du serveur pour les courtiers de San Francisco (GMT-8), àlundi, 09:00 AM heure du serveur pour les courtiers de Sydney (GMT+11). La fin de la semaine de trading varie également duvendredi, 14h00, heure du serveur, ausamedi, 09h00, heure du serveur.
Chaque courtier est libre de choisir son heure d'été (DST). Et l'heure d'été n'est pas nécessairement la même pour chaque fuseau horaire. Parfois, ils mélangent les deux en utilisant un fuseau horaire européen et une heure d'été américaine au lieu de l'heure d'été européenne. Pour les courtiers qui ne suivent pas le calendrier américain, l'heure du serveur pour le début (et la fin) de la semaine varie de +/- une heure pour le même courtier tout au long de l'année. La méthode ForexCloseTime() gère ces variations inter- et intra-courtier en convertissant l'heure de clôture à NYC le vendredi 17:00 à l'heure du courtier, en tenant compte des décalages horaires et de l'heure d'été, ce qui permet d'obtenir des résultats précis.
L'utilisation d'un fuseau horaire de +2 (et +3 en été sur l'horaire américain) signifie donc qu'il y a cinq bougies D1 par semaine. Il n'y a pas de bougies le samedi et le dimanche tout au long de l'année. Simplement, l 'heure sur ces serveurs est toujours en avance de 7 heures sur New York et représentée par NY+7. C'est de loin le réglage le plus courant, mais il existe de nombreuses variantes moins courantes.
Exemple d'indicateur TestIndi.mq5
iForexSessions - indicateur pour MetaTrader 5
Met en évidence les sessions du marché Forex
Obtenez-le ici https://www.mql5.com/fr/code/48842
Liens
Horloge mondiale : https://www.timeanddate.com/worldclock/
Convertisseur de fuseaux horaires : https://www.timeanddate.com/worldclock/converter-classic.html
Mises à jour :
2024.03.01 - v.1.40 : Suppression du code redondant dans la classe CTimeZoneInfo (utilisée pendant les tests), ajout de méthodes à la classe CSessionHours, mise à jour de TestIndi.mq5 pour refléter les nouveaux changements.
2024.03.03 - v.1.45 : Mise à jour du code d'exemple pour "Working with Local Session Hours - CTimeZoneInfo Class".
2024.03.08 - v.1.50 : Ajout de deux méthodes internes HistoryBrokerOffset et FirstBarOfWeek à la classe CTimeZoneInfo. Gestion de l'heure du serveur dans le passé (décalage UTC, formatage du texte, conversions, etc...).
2024.03.15 - v.1.56 : Ajout du script "SydneySession_Script.mq5" pour montrer comment les heures de session à Sydney fluctuent tout au long de l'année.
2024.03.30 - v.1.65 : Correction du décalage GMT du broker. Actuellement, la bibliothèque ne scanne les barres H1 que sur le graphique GOLD car il a les heures de début les plus précises sur tous les courtiers que j'ai testés.
2024.04.01 - v.1.67 : Correction d'un problème potentiel dans le calcul du décalage GMT du courtier pendant la première heure de la semaine de trading.
2024.04.03 - v.1.70 : Mise en cache des décalages GMT des courtiers dans une carte de hachage pour une récupération plus rapide (par exemple, à partir d'indicateurs). Le cache de l'offset des courtiers contiendra une entrée par semaine de trading.
2024.04.08 - v.1.72 : Amélioration des performances de la bibliothèque d'au moins 2 à 3 fois. Utilisation de StructToTime au lieu de StringToTime dans la méthode GetNthSunday.
2024.04.09 - v.1.75 : Correction d'un problème potentiel dans le calcul du décalage GMT des courtiers pendant les vacances de Noël sur les courtiers GMT+0.
2024.04.11 - v.1.77 : Accélération de la méthode GetDaylightSwitchTimes. Utilise maintenant un tableau statique pour mémoriser les heures de commutation pour l'année en cours.
2024.04.12 - v.1.80 : Correction d'un problème dans le calcul du décalage GMT du courtier sur les courtiers qui n'offrent pas d'opérations sur l'or.
2024.04.15 - v.1.82 : Ajout de la méthode SetCustomTimeZone à la classe CTimeZoneInfo, que vous pouvez utiliser pour configurer le fuseau horaire personnalisé intégré avec un nom spécifié, un décalage GMT et un identifiant DST. Le fuseau horaire personnalisé est accessible via ZONE_ID_CUSTOM.
2024.04.16 - v.1.85 : Remplacement de la méthode interne GetNthSunday par la méthode GetMonthTime, plus optimisée.
2024.04.17 - v.1.87 : Remplacement de la méthode interne TimeYear par la méthode GetYear plus optimisée.
2024.04.18 - v.1.88 : Ajout de la méthode interne CreateDateTime pour construire des valeurs de date à partir des composants de la date (année, mois et jour). Cette méthode est 100 à 120 fois plus rapide que l'appel à la fonction StructToTime.
2024.10.22 - v.1.93 : Détermination plus rapide du décalage GMT du serveur pendant le week-end en trading live.
2024.10.26 - v.1.95 : Ajout de deux nouvelles méthodes statiques : TimeGMTOffset() et TimeDaylightSavings(). Renommé la méthode HistoryBrokerOffset() en TimeServerGMTOffset().
2024.10.28 - v.1.97 : Conversion de toutes les macros traitant du temps en fonctions pour éviter la double évaluation des paramètres dans le corps de la macro. Plus de nettoyage de code dans d'autres lignes.
2024.10.30 - v.1.98 : Correction d'un problème d'estimation erronée du décalage GMT à partir des cotations XAUEUR sur certains courtiers.
2024.11.01 - v.1.99 : Ajout d'une option pour désactiver le chargement par défaut du symbole Gold pour l'estimation du TZ/DST du serveur. Appelez CTimeZoneInfo:: SetUsingGoldSymbol() avec 'false' pour utiliser le symbole du graphique actuel à la place.
2024.11.13 - v.2.00 : Amélioration de l'estimation du serveur en ligne tz/dst et dans la stratégie (la bibliothèque TimeGMT n'est plus nécessaire). Le constructeur accepte les paramètres de lieu et de temps. Nouvelles méthodes publiques pour travailler avec des données de type datetime. Amélioration de la gestion des erreurs et du débogage.
2024.11.14 - v.2.02 : Correction de l'erreur ERR_HISTORY_NOT_FOUND (4401) lors de l'accès à l'historique des cotations XAUUSD,H1 par l'objet timezone du serveur.
2024.11.17 - v.2.03 : Correction de bugs mineurs.
2024.11.23 - v.2.04 : Améliorations mineures et corrections de bugs.
2024.12.05 - v.2.05 : Ajout d'une nouvelle méthode statique DaylightSavingsSupported(placeId).
2024.12.12 - v.2.10 : Amélioration des performances des fonctions HistoryServerGMTOffset() et HistoryServerDaylightSavings(), et autres modifications mineures du code.
2024.12.14 - v.2.11 : Amélioration des performances de la fonction FindSymbol().
2024.12.17 - v.2.12 : Optimisation des fonctions HistoryServerGMTOffset() et HistoryServerDaylightSavings().
2024.12.24 - v.2.13 : Correction d'un problème potentiel dans les fonctions HistoryServerGMTOffset() et HistoryServerDaylightSavings().
2025.01.12 - v.2.15 : Correction d'un problème dans la fonction HistoryServerDaylightSavings() concernant la recherche d'un historique de cotations antérieur à l'historique chargé dans le testeur de stratégie.
2025.10.13 - v.2.17 : Améliorations mineures et corrections de bugs.
Traduit de l’anglais par MetaQuotes Ltd.
Code original : https://www.mql5.com/en/code/48419
CVD (Cumulative Volume Delta)
Lightweight CVD (Cumulative Volume Delta) pour MT5 - basé sur M1, montre la pression d'achat/vente sous forme de bougies avec des réinitialisations optionnelles.
CFastFile - classe permettant de travailler avec un tableau d'octets en tant que fichier
La classe CFastFile élimine le besoin d'écriture intermédiaire des données dans un fichier physique sur le disque. Cela permet d'accélérer considérablement le traitement des données.
MA-Env
Enveloppes de moyennes mobiles.
Fonctions statistiques statistics.mqh
Une bibliothèque qui contient des fonctions statistiques telles que le calcul de la moyenne, de la variance, de l'asymétrie, de l'excès, de la covariance, de la corrélation, etc.