Sujet Précédent Sujet Suivant

Modifier ma valeur timer par programmation

ManuAntibes Messages postés 491 Date d'inscription mardi 24 octobre 2000 Statut Membre Dernière intervention 18 novembre 2021 - 15 nov. 2021 à 10:56
Whismeril Messages postés 19145 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 29 septembre 2024 - 19 nov. 2021 à 00:02
Bonjour,

J'ai sur mon appli un bandeau timer avec Semaine jour et heure.

J'ai un timer de 20000 miliseconde pour modifier les heures -> jours -> semaine.

le tous est dans une class et ma valeur 20000 est dans une variable (Milli_seconde).


je veux pouvoir modifier la valeur de ma variable Milli_seconde pour que l'utilisateur accélere le temps de jeu surtout la période nuit.

voici mon code dans la class infoBoutique.
public int Milli_seconde { get; set; }

public Timer ATimer { get; set; }

public void SetTimer()
{
// Créez une minuterie avec un intervalle de 20 secondes réelle = 1 heure dans l'appli.
ATimer = new Timer(Milli_seconde); // Milli_seconde = 20 000
// Connectez l'événement OnTimedEvent pour la minuterie.
ATimer.Elapsed += OnTimedEvent; // Sur événement chronométré
ATimer.AutoReset = true;
ATimer.Enabled = true;
ATimer.Start();
}
private void OnTimedEvent(object source, ElapsedEventArgs e)
{
Heure_Jeu += 1;

if (Heure_Jeu == 24)
{
Heure_Jeu = 0;
Jour_Jeu += 1;
}
if (Jour_Jeu == 8)
{
Jour_Jeu = 1;
Semaine_Jeu += 1;
}
}

voici mon code dans les pages de l'appli.
#region Modification_Bandeau_Date

public void SetTimer()
{
// Créez une minuterie avec un intervalle de deux secondes = 20000.
aTimer = new Timer(infoBoutique.Milli_seconde);
// Connectez l'événement.
aTimer.Elapsed += ModifBandeauDate;
aTimer.AutoReset = true;
aTimer.Enabled = true;
}

private void ModifBandeauDate(object source, ElapsedEventArgs e)
{
Device.BeginInvokeOnMainThread(() => NumSemaine.Text = infoBoutique.Semaine_Jeu.ToString());
Device.BeginInvokeOnMainThread(() => HeureJour.Text = infoBoutique.Heure_Jeu.ToString() + "h");
Device.BeginInvokeOnMainThread(() => JoursSemaine.Text = infoBoutique.ConvertirNumJour_LettreJour(infoBoutique.Jour_Jeu));
}

#endregion


j'ai essayé de code pour modifier le timer
infoBoutique.Milli_seconde = 1000;

Lorsque je fais un débogage la valeur de Milli_seconde est bien modifier , mais pas la vitesse du jeu, la date change toujours toutes les 20 secondes en temps réelle.

Si vous avez une idée merci à tous.
Manu
A voir également:

11 réponses

Réponse 1 / 11
Whismeril Messages postés 19145 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 29 septembre 2024 660
15 nov. 2021 à 20:22
Oui c'est mieux, mais ça fait quand même mal à la tête.

Si j'ai compris ce que tu veux faire alors tu te compliques la vie à un point....
Du genre, tu coules tes 2 jambes et tes 2 bras dans le béton juste avant de faire un 50m en crawl...

Bon répondons "bêtement" à
j'ai essayé de code ça pour modifier le timer 
infoBoutique.Milli_seconde = 1000;


Lorsque je fais un débogage la valeur de Milli_seconde est bien modifier , mais pas la vitesse du jeu, la date change toujours toutes les 20 secondes en temps réelle.


La propriété 
public int Milli_seconde { get; set; }
n'a pas de corps, ça veut dire qu'elle stocke la valeur, mais n'en fait rien, et notamment, elle ne change pas l'intervalle du timer.

On pourrait donc être tenté de faire ceci 
infoBoutique.Milli_seconde = 1000;
infoBoutique. SetTimer();

Puisque dans cette méthode, on affecte l'intervalle avec la propriété et en plus cette méthode a le nom qui y fait penser "on saisit la propriété et on la Set".
Sauf que ce serait une très mauvaise idée. Dans cette méthode, on crée une nouvelle instance de ATimer (peut importe qu'il en existe déjà une ou pas) et on initialise tout ce qui est nécessaire. Donc on se retrouve avec 2 instances, qui ne tournent pas en même temps et qui vont entrer en conflit....
Bref SetTimer en l'état devrait s'appeler InitTimer ou alors ne pas être codée comme ça.

On pourrait aussi modifier la propriété comme ça 
        public int Milli_seconde
        {
            get { return ATimer.Interval; }
            set { ATimer.Interval = value; }
        }

Là au moins on agit sur le timer.

Mais comme tu as choisis (pas forcément judicieux) de mettre ton timer public, le plus simple c'est de supprimer la propriété Milli_seconde, remplacer par 20000 dans SetTimer et de remplacer 
infoBoutique.Milli_seconde = 1000;

par 
infoBoutique.ATimer.Interval = 1000;



Mais avec tout ça on a encore du béton partout.
  • A quoi te sert il d'avoir un timer qui lance un timer pour faire des invoke?
  • Là 
    Heure_Jeu += 1;
if (Heure_Jeu == 24)
{
Heure_Jeu = 0;
Jour_Jeu += 1;
}
if (Jour_Jeu == 8)
{
Jour_Jeu = 1;
Semaine_Jeu += 1;
    connais tu le type TimeSpan? Jette un oeil, ça fait ça plus ou moins tout seul
1
Réponse 2 / 11
Whismeril Messages postés 19145 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 29 septembre 2024 660
16 nov. 2021 à 20:14
Bon t'as pas validé, mais j'avais un peu de temps et "envie de jouer"

Alors j'ai défini un enum pour 4 "vitesses" d'écoulement du temps 
    enum Ecoulement
    {
        Normal = 20000,
        Rapide = 10000,
        TresRapide = 5000,
        Extreme = 1000
    }


Puis j'ai écrit cette classe 
    class TempsManu : INotifyPropertyChanged
    {

        private Timer timer = new Timer();
        private TimeSpan compteur = new TimeSpan();
        private TimeSpan uneHeure = TimeSpan.FromHours(1);

        #region Constructeurs
        /// <summary>
        /// Constructeur par défaut
        /// </summary>
        public TempsManu()
        {
            timer.Interval = (int)ecoulementNuit;
            timer.Tick += Timer_Tick;
        }

        /// <summary>
        /// Constrcuteur avec définition du jour et de la nuit
        /// </summary>
        /// <param name="LAube"></param>
        /// <param name="LeCrepuscule"></param>
        public TempsManu(uint LAube, uint LeCrepuscule):this()
        {
            if (LeCrepuscule > 24 || LAube >= LeCrepuscule)
                throw new Exception("Définition du jour et de la nuit impossible");

            Aube = LAube;
            Crepuscule = LeCrepuscule;
            GestionDuTemps();
        }

        #endregion

        #region Proprietes
        private Ecoulement ecoulementNuit = Ecoulement.Rapide;
        /// <summary>
        /// Ecoulement du temps la nuit
        /// </summary>
        public Ecoulement EcoulementNuit
        {
            get { return ecoulementNuit; }
            set
            {
                if (ecoulementNuit != value)
                {
                    ecoulementNuit = value;
                    GenerePropertyChanged("EcoulementNuit");

                    if (nuit)
                        timer.Interval = (int)value;
                }
            }
        }

        private Ecoulement ecoulementJour = Ecoulement.Normal;
        /// <summary>
        /// Ecoulement du temps le jour
        /// </summary>
        public Ecoulement EcoulementJour
        {
            get { return ecoulementJour; }
            set
            {
                if (ecoulementJour != value)
                {
                    ecoulementJour = value;
                    GenerePropertyChanged("EcoulementJour");

                    if (!nuit)
                        timer.Interval = (int)value;
                }
            }
        }

        private int semaine = 0;
        /// <summary>
        /// Retourne la semaine en cours
        /// </summary>
        public int Semaine
        {
            get { return semaine; }
            private set
            {
                if (semaine != value)
                {
                    semaine = value;
                    GenerePropertyChanged("Semaine");
                }
            }
        }

        private int jour = 0;
        /// <summary>
        /// Retourne le jour en cours
        /// </summary>
        public int Jour
        {
            get { return jour; }
            private set
            {
                if (jour != value)
                {
                    jour = value;
                    GenerePropertyChanged("Jour");
                }
            }
        }

        private int heure = 0;
        /// <summary>
        /// Retourne l'heure en cours
        /// </summary>
        public int Heure
        {
            get { return heure; }
            private set
            {
                if (heure != value)
                {
                    heure = value;
                    GenerePropertyChanged("Heure");
                }
            }
        }

        private bool nuit = true;
        /// <summary>
        /// Retourne si on est la nuit ou le jour
        /// </summary>
        public bool Nuit
        {
            get { return nuit; }
            private set
            {
                if (nuit != value)
                {
                    nuit = value;
                    GenerePropertyChanged("Nuit");
                }
            }
        }

        private uint aube = 6;
        /// <summary>
        /// Retourne l'heure du lever de soleil
        /// </summary>
        public uint Aube
        {
            get { return aube; }
            private set
            {
                if (aube != value)
                {
                    aube = value;
                    GenerePropertyChanged("Aube");
                }
            }
        }

        private uint crepuscule = 20;
        /// <summary>
        /// Retourne l'heure de coucher du soleil
        /// </summary>
        public uint Crepuscule
        {
            get { return crepuscule; }
            private set
            {
                if (crepuscule != value)
                {
                    crepuscule = value;
                    GenerePropertyChanged("Crepuscule");
                }
            }
        }


        #endregion


        #region Méthodes
        /// <summary>
        /// Décompte le temps qui passe
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Timer_Tick(object sender, EventArgs e)
        {
            compteur += uneHeure;

            GestionDuTemps();
        }

        /// <summary>
        /// Calcule le temps et met à jour les propriétés
        /// </summary>
        private void GestionDuTemps()
        {
            if (compteur.Days == 8)//on change de semaine
            {
                Semaine++; //j'utilise la propriété pour déclencher l'évènement PropretyChanged
                compteur = new TimeSpan();
            }
            Jour = compteur.Days; //j'utilise la propriété pour déclencher l'évènement PropretyChanged
            Heure = compteur.Hours; //j'utilise la propriété pour déclencher l'évènement PropretyChanged


            //Gestion automatique du jour et de la nuit
            if (Heure == aube)
            {
                Nuit = false; //j'utilise la propriété pour déclencher l'évènement PropretyChanged
                timer.Interval = (int)ecoulementJour;
            }
            else if (Heure == crepuscule)
            {
                Nuit = true; //j'utilise la propriété pour déclencher l'évènement PropretyChanged
                timer.Interval = (int)ecoulementNuit;
            }


            //Signalement que le temps vient de changer (ou de démarer)
            Tick?.Invoke(this, semaine, jour, heure);
        }

        /// <summary>
        /// Démarre le temps du jeux avec un offset en heure optionnel
        /// </summary>
        /// <param name="HeureDeDepart"</param>
        public void Start(uint HeureDeDepart = 0)
        {
            if (HeureDeDepart != 0)
            {
                Semaine = (int)HeureDeDepart / 168;

                compteur = TimeSpan.FromHours(HeureDeDepart % 168);
                Nuit = compteur.Hours < aube || compteur.Hours >= crepuscule;
                timer.Interval = nuit ? (int)ecoulementNuit : (int)ecoulementJour;
            }

            GestionDuTemps();
            timer.Start();
        }

        #endregion

        #region Evènements
        public delegate void TickEvent(TempsManu Sender, int LaSemaine, int LeJour, int Lheure);
        /// <summary>
        /// Se déclence à chaque "coup d'horloge"
        /// </summary>
        public event TickEvent Tick;

        #endregion

        #region INotifyPropertyChanged
        public event PropertyChangedEventHandler PropertyChanged;
        /// <summary>
        /// Signale à l'IHM un changement de valeur d'une propriété
        /// </summary>
        /// <param name="Propriete"></param>
        private void GenerePropertyChanged(string Propriete)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(Propriete));
        }

        #endregion
    }


Dans un formulaire, j'ai mis 2 label, l'un est bindé sur la propriété "Heure" de la propriété l'autre non et ce code 

    class TempsManu : INotifyPropertyChanged
    {

        private Timer timer = new Timer();
        private TimeSpan compteur = new TimeSpan();
        private TimeSpan uneHeure = TimeSpan.FromHours(1);

        #region Constructeurs
        /// <summary>
        /// Constructeur par défaut
        /// </summary>
        public TempsManu()
        {
            timer.Interval = (int)ecoulementNuit;
            timer.Tick += Timer_Tick;
        }

        /// <summary>
        /// Constrcuteur avec définition du jour et de la nuit
        /// </summary>
        /// <param name="LAube"></param>
        /// <param name="LeCrepuscule"></param>
        public TempsManu(uint LAube, uint LeCrepuscule):this()
        {
            if (LeCrepuscule > 24 || LAube >= LeCrepuscule)
                throw new Exception("Définition du jour et de la nuit impossible");

            Aube = LAube;
            Crepuscule = LeCrepuscule;
            GestionDuTemps();
        }

        #endregion

        #region Proprietes
        private Ecoulement ecoulementNuit = Ecoulement.Rapide;
        /// <summary>
        /// Ecoulement du temps la nuit
        /// </summary>
        public Ecoulement EcoulementNuit
        {
            get { return ecoulementNuit; }
            set
            {
                if (ecoulementNuit != value)
                {
                    ecoulementNuit = value;
                    GenerePropertyChanged("EcoulementNuit");

                    if (nuit)
                        timer.Interval = (int)value;
                }
            }
        }

        private Ecoulement ecoulementJour = Ecoulement.Normal;
        /// <summary>
        /// Ecoulement du temps le jour
        /// </summary>
        public Ecoulement EcoulementJour
        {
            get { return ecoulementJour; }
            set
            {
                if (ecoulementJour != value)
                {
                    ecoulementJour = value;
                    GenerePropertyChanged("EcoulementJour");

                    if (!nuit)
                        timer.Interval = (int)value;
                }
            }
        }

        private int semaine = 0;
        /// <summary>
        /// Retourne la semaine en cours
        /// </summary>
        public int Semaine
        {
            get { return semaine; }
            private set
            {
                if (semaine != value)
                {
                    semaine = value;
                    GenerePropertyChanged("Semaine");
                }
            }
        }

        private int jour = 0;
        /// <summary>
        /// Retourne le jour en cours
        /// </summary>
        public int Jour
        {
            get { return jour; }
            private set
            {
                if (jour != value)
                {
                    jour = value;
                    GenerePropertyChanged("Jour");
                }
            }
        }

        private int heure = 0;
        /// <summary>
        /// Retourne l'heure en cours
        /// </summary>
        public int Heure
        {
            get { return heure; }
            private set
            {
                if (heure != value)
                {
                    heure = value;
                    GenerePropertyChanged("Heure");
                }
            }
        }

        private bool nuit = true;
        /// <summary>
        /// Retourne si on est la nuit ou le jour
        /// </summary>
        public bool Nuit
        {
            get { return nuit; }
            private set
            {
                if (nuit != value)
                {
                    nuit = value;
                    GenerePropertyChanged("Nuit");
                }
            }
        }

        private uint aube = 6;
        /// <summary>
        /// Retourne l'heure du lever de soleil
        /// </summary>
        public uint Aube
        {
            get { return aube; }
            private set
            {
                if (aube != value)
                {
                    aube = value;
                    GenerePropertyChanged("Aube");
                }
            }
        }

        private uint crepuscule = 20;
        /// <summary>
        /// Retourne l'heure de coucher du soleil
        /// </summary>
        public uint Crepuscule
        {
            get { return crepuscule; }
            private set
            {
                if (crepuscule != value)
                {
                    crepuscule = value;
                    GenerePropertyChanged("Crepuscule");
                }
            }
        }


        #endregion


        #region Méthodes
        /// <summary>
        /// Décompte le temps qui passe
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Timer_Tick(object sender, EventArgs e)
        {
            compteur += uneHeure;

            GestionDuTemps();
        }

        /// <summary>
        /// Calcule le temps et met à jour les propriétés
        /// </summary>
        private void GestionDuTemps()
        {
            if (compteur.Days == 8)//on change de semaine
            {
                Semaine++; //j'utilise la propriété pour déclencher l'évènement PropretyChanged
                compteur = new TimeSpan();
            }
            Jour = compteur.Days; //j'utilise la propriété pour déclencher l'évènement PropretyChanged
            Heure = compteur.Hours; //j'utilise la propriété pour déclencher l'évènement PropretyChanged


            //Gestion automatique du jour et de la nuit
            if (Heure == aube)
            {
                Nuit = false; //j'utilise la propriété pour déclencher l'évènement PropretyChanged
                timer.Interval = (int)ecoulementJour;
            }
            else if (Heure == crepuscule)
            {
                Nuit = true; //j'utilise la propriété pour déclencher l'évènement PropretyChanged
                timer.Interval = (int)ecoulementNuit;
            }


            //Signalement que le temps vient de changer (ou de démarer)
            Tick?.Invoke(this, semaine, jour, heure);
        }

        /// <summary>
        /// Démarre le temps du jeux avec un offset en heure optionnel
        /// </summary>
        /// <param name="HeureDeDepart"</param>
        public void Start(uint HeureDeDepart = 0)
        {
            if (HeureDeDepart != 0)
            {
                Semaine = (int)HeureDeDepart / 168;

                compteur = TimeSpan.FromHours(HeureDeDepart % 168);
                Nuit = compteur.Hours < aube || compteur.Hours >= crepuscule;
                timer.Interval = nuit ? (int)ecoulementNuit : (int)ecoulementJour;
            }

            GestionDuTemps();
            timer.Start();
        }

        #endregion

        #region Evènements
        public delegate void TickEvent(TempsManu Sender, int LaSemaine, int LeJour, int Lheure);
        /// <summary>
        /// Se déclenche à chaque "coup d'horloge"
        /// </summary>
        public event TickEvent Tick;

        #endregion

        #region INotifyPropertyChanged
        public event PropertyChangedEventHandler PropertyChanged;
        /// <summary>
        /// Signale à l'IHM un changement de valeur d'une propriété
        /// </summary>
        /// <param name="Propriete"></param>
        private void GenerePropertyChanged(string Propriete)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(Propriete));
        }

        #endregion
    }

1
Réponse 3 / 11
Whismeril Messages postés 19145 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 29 septembre 2024 660
15 nov. 2021 à 11:38
Bonjour

depuis le temps que tu es membre, tu devrais penser à utiliser les balises de code, rappel
https://codes-sources.commentcamarche.net/faq/11288-les-balises-de-code

Là franchement, je n'ai pas envie de lire.
0
Réponse 4 / 11
ManuAntibes Messages postés 491 Date d'inscription mardi 24 octobre 2000 Statut Membre Dernière intervention 18 novembre 2021 5
Modifié le 15 nov. 2021 à 18:50
Oui, mille excuses. cela fait longtemps que je n'étais pas revenu. mais ce n'est pas une excuse...

voici mon code dans la class infoBoutique. 
public int Milli_seconde { get; set; }
public Timer ATimer { get; set; }

public void SetTimer()
{
// Créez une minuterie avec un intervalle de 20 secondes réelle = 1 heure dans l'appli.
ATimer = new Timer(Milli_seconde); // Milli_seconde = 20 000
// Connectez l'événement OnTimedEvent pour la minuterie.
ATimer.Elapsed += OnTimedEvent; // Sur événement chronométré
ATimer.AutoReset = true;
ATimer.Enabled = true;
ATimer.Start();
}
private void OnTimedEvent(object source, ElapsedEventArgs e)
{
Heure_Jeu += 1;
if (Heure_Jeu == 24)
{
Heure_Jeu = 0;
Jour_Jeu += 1;
}
if (Jour_Jeu == 8)
{
Jour_Jeu = 1;
Semaine_Jeu += 1;
}}



voici mon code dans les pages de l'appli. 

#region Modification_Bandeau_Date

public void SetTimer()
{
// Créez une minuterie avec un intervalle de deux secondes = 20000.
aTimer = new Timer(infoBoutique.Milli_seconde);
// Connectez l'événement.
aTimer.Elapsed += ModifBandeauDate;
aTimer.AutoReset = true;
aTimer.Enabled = true;
}

private void ModifBandeauDate(object source, ElapsedEventArgs e)
{
Device.BeginInvokeOnMainThread(() => NumSemaine.Text = infoBoutique.Semaine_Jeu.ToString());
Device.BeginInvokeOnMainThread(() => HeureJour.Text = infoBoutique.Heure_Jeu.ToString() + "h");
Device.BeginInvokeOnMainThread(() => JoursSemaine.Text = infoBoutique.ConvertirNumJour_LettreJour(infoBoutique.Jour_Jeu));
}
#endregion


j'ai essayé de code ça pour modifier le timer 
infoBoutique.Milli_seconde = 1000;


Lorsque je fais un débogage la valeur de Milli_seconde est bien modifier , mais pas la vitesse du jeu, la date change toujours toutes les 20 secondes en temps réelle.
c'est plus lisible maintenant en effet.
Au plaisir
Manu
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 11
ManuAntibes Messages postés 491 Date d'inscription mardi 24 octobre 2000 Statut Membre Dernière intervention 18 novembre 2021 5
16 nov. 2021 à 11:14
Salut

Bon j'ai regardé Timespan,
sur docs.microsoft.com : Il compare beaucoup entre deux dates.

et j'ai cherché "Chronometre c# timespan" sur le net, j'ai trouvé des exemples, qui mon bien aidé.
Merci à toi.
0
Réponse 6 / 11
Whismeril Messages postés 19145 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 29 septembre 2024 660
16 nov. 2021 à 13:01
Oui de base une timespan compare des dates, mais il s’agit d’une durée. Ce qui me semble être ton besoin.
En plus il donne directement jours, heures et minutes. Tu n’aurais donc qu’une remise à zéro qu’au 8eme jour.

Si je comprends bien ça doit être la base de temps de ton jeu (donc pas vraiment un chronomètre qui lui repose sur la base de temps de l’ordi).
Cette base doit être à vitesse variable avec une différence jour / nuit.

Je suppose que tout ton jeu doit s’y accorder donc elle doit « signaler » ses changements.

Est-ce bien cela? Si oui je peux essayer te faire un exemple dans la soirée.
0
Réponse 7 / 11
ManuAntibes Messages postés 491 Date d'inscription mardi 24 octobre 2000 Statut Membre Dernière intervention 18 novembre 2021 5
17 nov. 2021 à 22:49
Bonsoir,

Merci pour le travail.
Je vois que tu t'es bien éclaté !!
je regarde mieux ça demain après midi. je serais en repos.

J'ai perdu un peu la main avec les class et enum ...
cela me remettra dans le bain.

Je dev une appli Andoid sur visual studio 2019, pour mes jeunes apprentis boucher.
avec achat de carcasse, découpe et vente aux clients, avec la date et les heures qui s'écoule.

Encore merci
Manu
0
Réponse 8 / 11
Whismeril Messages postés 19145 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 29 septembre 2024 660
17 nov. 2021 à 23:03
Ha, je n'ai pas mis les noms des jours de la semaine....
Et puis je l'ai fait bêtement informaticien, ça commence la semaine 0...

Mais bon c'est des petites modifs
0
Réponse 9 / 11
ManuAntibes Messages postés 491 Date d'inscription mardi 24 octobre 2000 Statut Membre Dernière intervention 18 novembre 2021 5
18 nov. 2021 à 21:18
Bonsoir,

Comment mets tu à jour tes labels dans ton form ?
je me suis servi de ton code dans une Appli Form.
Moi j'ai utiliser un Timer pour mettre à jour les Labels. 

 private void timer1_Tick(object sender, EventArgs e)
        {
            label1.Text ="Semaine: " + tempsManu.Semaine.ToString()+ " - Jour: "+ tempsManu.Jour.ToString() + " - heure: "+ tempsManu.Heure.ToString()+ "h";
            label2.Text = tempsManu.Nuit.ToString();

        }




Je trouve ton code très bien ecris, mais assez compliquer avec tous les proprietes .
j'ai bien galere pour le faire fonctionner et mettre tous les Using .... et les System.Windows.Forms...

encore merci
Bonne soirée
0
Réponse 10 / 11
Whismeril Messages postés 19145 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 29 septembre 2024 660
18 nov. 2021 à 23:46
Haaa zut, je m'aperçois que j'ai posté 2 fois le code de la classe et pas celui du formulaire....
Et comme t'avais pas parlé d'appli android, je pensais que tu étais en winform (d'où le timer winform, mais on peut très bien utiliser n'importe lequel). C'est en général l'interface par défaut en C#.

Les langages .Net sont des langages objets (pas juste orientés objet), et un objet ça peut s'écrire avec des évènements, des méthodes, des constructeurs, des propriétés et des interfaces.

Pour celui-là j'ai utilisé un peu de tout.
On peut construire une instance avec ou sans paramètres et lancer le "temps" avec la méthode Start, là aussi avec ou sans paramètre 
       private void Form3_Load(object sender, EventArgs e)
        {
            //tempsManu = new TempsManu();
            //ou alors
            tempsManu = new TempsManu(5, 21);//pour définir le jour et la nuit

            tempsManu.Tick += TempsManu_Tick;//on abonne le programme à la base de temps

            tempsManuBindingSource.DataSource = tempsManu;//on lie le binding winform

            tempsManu.EcoulementJour = Ecoulement.TresRapide;
            tempsManu.EcoulementNuit = Ecoulement.Extreme;
            
            //tempsManu.Start();
            //ou alors
            tempsManu.Start(300);//pour démarrer au cours de la 2eme semaine


        }


Le premier label est alimenté au déclenchement d'un évènement 


        /// <summary>
        /// Le programme agit en fonction du temps, car il est abonné à l'évènement Tick
        /// </summary>
        /// <param name="Sender"></param>
        /// <param name="LaSemaine"></param>
        /// <param name="LeJour"></param>
        /// <param name="Lheure"></param>
        private void TempsManu_Tick(TempsManu Sender, int LaSemaine, int LeJour, int Lheure)
        {
            lblTemps.Text = $"Nous sommes le jour {LeJour} de la semaine {LaSemaine}, il est {Lheure} heures et il fait {(Sender.Nuit ? "nuit" : "jour")}";
        }



Pour le second label, il est bindé. (bon mon exemple est en winform)
C'est un des points forts de .Net.
Et ça marche avec des propriétés qui déclenchent l'évènement ProrpertyChanged (le binding se met à jour à ce moment là). Cet évènement vient d'une interface.

Je n'ai jamais codé d'appli mobile, mais de ce que j'en ai vu c'est très proche de WPF. Donc voilà un modeste tuto sur le binding en WPF
https://codes-sources.commentcamarche.net/faq/11277-apercu-du-binding-en-wpf

Mais il requiert de bien cerner les objets.
J'ai aussi écrit une série sur l'objet, abordé avec mon prisme autodidacte
https://codes-sources.commentcamarche.net/faq/11239-la-programmation-objet-appliquee-a-net-par-l-exemple-partie-1-sur-3
0
Réponse 11 / 11
Whismeril Messages postés 19145 Date d'inscription mardi 11 mars 2003 Statut Contributeur Dernière intervention 29 septembre 2024 660
19 nov. 2021 à 00:02
J'ai ajouté les noms des jours, et commencé à la semaine 1 

    class TempsManu : INotifyPropertyChanged
    {

        private Timer timer = new Timer();
        private TimeSpan compteur = new TimeSpan();
        private TimeSpan uneHeure = TimeSpan.FromHours(1);
        private string[] nomsJours = { "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche" };


        #region Constructeurs
        /// <summary>
        /// Constructeur par défaut
        /// </summary>
        public TempsManu()
        {
            timer.Interval = (int)ecoulementNuit;
            timer.Tick += Timer_Tick;
        }

        /// <summary>
        /// Constrcuteur avec définition du jour et de la nuit
        /// </summary>
        /// <param name="LAube"></param>
        /// <param name="LeCrepuscule"></param>
        public TempsManu(uint LAube, uint LeCrepuscule):this()
        {
            if (LeCrepuscule > 24 || LAube >= LeCrepuscule)
                throw new Exception("Définition du jour et de la nuit impossible");

            Aube = LAube;
            Crepuscule = LeCrepuscule;
            GestionDuTemps();
        }

        #endregion

        #region Proprietes
        private Ecoulement ecoulementNuit = Ecoulement.Rapide;
        /// <summary>
        /// Ecoulement du temps la nuit
        /// </summary>
        public Ecoulement EcoulementNuit
        {
            get { return ecoulementNuit; }
            set
            {
                if (ecoulementNuit != value)
                {
                    ecoulementNuit = value;
                    GenerePropertyChanged("EcoulementNuit");

                    if (nuit)
                        timer.Interval = (int)value;
                }
            }
        }

        private Ecoulement ecoulementJour = Ecoulement.Normal;
        /// <summary>
        /// Ecoulement du temps le jour
        /// </summary>
        public Ecoulement EcoulementJour
        {
            get { return ecoulementJour; }
            set
            {
                if (ecoulementJour != value)
                {
                    ecoulementJour = value;
                    GenerePropertyChanged("EcoulementJour");

                    if (!nuit)
                        timer.Interval = (int)value;
                }
            }
        }

        private int semaine = 1;
        /// <summary>
        /// Retourne la semaine en cours
        /// </summary>
        public int Semaine
        {
            get { return semaine; }
            private set
            {
                if (semaine != value)
                {
                    semaine = value;
                    GenerePropertyChanged("Semaine");
                }
            }
        }

        private int jour = 0;
        /// <summary>
        /// Retourne le jour en cours
        /// </summary>
        public int Jour
        {
            get { return jour; }
            private set
            {
                if (jour != value)
                {
                    jour = value;
                    GenerePropertyChanged("Jour");
                    GenerePropertyChanged("NomJour");//Si on signale que le jour a changé, il faut signaler que son nom aussi
                }
            }
        }

        /// <summary>
        /// Nom du jour en cours
        /// </summary>
        public string NomJour
        {
            get { return nomsJours[jour]; }
        }

        private int heure = 0;
        /// <summary>
        /// Retourne l'heure en cours
        /// </summary>
        public int Heure
        {
            get { return heure; }
            private set
            {
                if (heure != value)
                {
                    heure = value;
                    GenerePropertyChanged("Heure");
                }
            }
        }

        private bool nuit = true;
        /// <summary>
        /// Retourne si on est la nuit ou le jour
        /// </summary>
        public bool Nuit
        {
            get { return nuit; }
            private set
            {
                if (nuit != value)
                {
                    nuit = value;
                    GenerePropertyChanged("Nuit");
                }
            }
        }

        private uint aube = 6;
        /// <summary>
        /// Retourne l'heure du lever de soleil
        /// </summary>
        public uint Aube
        {
            get { return aube; }
            private set
            {
                if (aube != value)
                {
                    aube = value;
                    GenerePropertyChanged("Aube");
                }
            }
        }

        private uint crepuscule = 20;
        /// <summary>
        /// Retourne l'heure de coucher du soleil
        /// </summary>
        public uint Crepuscule
        {
            get { return crepuscule; }
            private set
            {
                if (crepuscule != value)
                {
                    crepuscule = value;
                    GenerePropertyChanged("Crepuscule");
                }
            }
        }


        #endregion


        #region Méthodes
        /// <summary>
        /// Décompte le temps qui passe
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Timer_Tick(object sender, EventArgs e)
        {
            compteur += uneHeure;

            GestionDuTemps();
        }

        /// <summary>
        /// Calcule le temps et met à jour les propriétés
        /// </summary>
        private void GestionDuTemps()
        {
            if (compteur.Days == 8)//on change de semaine
            {
                Semaine++; //j'utilise la propriété pour déclencher l'évènement PropretyChanged
                compteur = new TimeSpan();
            }
            Jour = compteur.Days; //j'utilise la propriété pour déclencher l'évènement PropretyChanged
            Heure = compteur.Hours; //j'utilise la propriété pour déclencher l'évènement PropretyChanged


            //Gestion automatique du jour et de la nuit
            if (Heure == aube)
            {
                Nuit = false; //j'utilise la propriété pour déclencher l'évènement PropretyChanged
                timer.Interval = (int)ecoulementJour;
            }
            else if (Heure == crepuscule)
            {
                Nuit = true; //j'utilise la propriété pour déclencher l'évènement PropretyChanged
                timer.Interval = (int)ecoulementNuit;
            }


            //Signalement que le temps vient de changer (ou de démarrer)
            Tick?.Invoke(this, semaine, jour, heure);
        }

        /// <summary>
        /// Démarre le temps du jeux avec un offset en heure optionnel
        /// </summary>
        /// <param name="HeureDeDepart"</param>
        public void Start(uint HeureDeDepart = 0)
        {
            if (HeureDeDepart != 0)
            {
                Semaine = (int)HeureDeDepart / 168 + 1;

                compteur = TimeSpan.FromHours(HeureDeDepart % 168);
                Nuit = compteur.Hours < aube || compteur.Hours >= crepuscule;
                timer.Interval = nuit ? (int)ecoulementNuit : (int)ecoulementJour;
            }

            GestionDuTemps();
            timer.Start();
        }

        #endregion

        #region Evènements
        public delegate void TickEvent(TempsManu Sender, int LaSemaine, int LeJour, int Lheure);
        /// <summary>
        /// Se déclenche à chaque "coup d'horloge"
        /// </summary>
        public event TickEvent Tick;

        #endregion

        #region INotifyPropertyChanged
        public event PropertyChangedEventHandler PropertyChanged;
        /// <summary>
        /// Signale à l'IHM un changement de valeur d'une propriété
        /// </summary>
        /// <param name="Propriete"></param>
        private void GenerePropertyChanged(string Propriete)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(Propriete));
        }

        #endregion
    }


Et dans le formulaire, la méthode abonnée à l'évènement peut être modifiée comme ça 
        private void TempsManu_Tick(TempsManu Sender, int LaSemaine, int LeJour, int Lheure)
        {
            lblTemps.Text = $"Nous sommes le {Sender.NomJour} de la semaine {LaSemaine}, il est {Lheure} heures et il fait {(Sender.Nuit ? "nuit" : "jour")}";
        }
0

Discussions similaires

Gestion d'un timer
shuyuntake -
shuyuntake -

2 réponses
Faire une pause dans un timer
Artaga -
racpp -

4 réponses
comment lancer un timer et arrêter ce dernier a partir d'une méthode sans utlise
aefmaaradji -
googlaz -

4 réponses
Timer haute précision
pitch069 -
cs_rt15 -

1 réponse
Utiliser un timer dans une form
pierrotm777 -
pierrotm777 -

5 réponses
Rejoignez-nous