Thread + Gestion évènment

Version imprimable

Salut à tous,
je débute en .net... J'aimerais réalisé un classe qui est munie d'un thread effecutant un contrôle d'une valeur sur un automate. Lorsque la valeur de mon automate change un évènement est déclenché. La méthode LamReadWord récupère une valeur. J'ai de la pène à comprendre comment structurer mon code avec le thread et la gestion d'évènement. Le but que étant que j'ai une méthode qui soit déclenché lors d'un changement. Vu que cette classe est en compilée en dll il est impératif que je travaille avec un évènement... Merci d'avance pour votre aide...

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
  public String LamReadWord(String readAddress)
        {
            ushort[] MyWordArray = new ushort[Convert.ToUInt16("1")];
            ushort MyStartAddress = Convert.ToUInt16(readAddress);
            bool ReadOutput = false;
            int result = this.Read(MyStartAddress, ref MyWordArray, ReadOutput);
            if (result == 0)
            {
                return MyWordArray[0].ToString();
            }
            else
            {
                System.Console.Write("ERROR - Read returns: " + result.ToString() + "\r\n");
                return "error";
            }
 
        }
 
        public delegate void ChangeHandler(object sender, ChangeEventArgs e);
        public event ChangeHandler valueChanged;
 
 
        public static void run(string o, string n)
        {
            Thread t = new Thread(
                new ThreadStart(
            ChangeEventArgs e = new ChangeEventArgs(o,n);
            while (t.IsAlive)
            {
                if (e.isChanged) 
                { 
                    valueChanged(this,e); 
                }      
            }
            ));
 
            t.Start;
        }
 
        public void onChange(object sender, ChangeEventArgs e)
        {
            Console.WriteLine("la vakeur a changée");
        }
 
 
    }
 
    public class ChangeEventArgs : EventArgs
    {
        public string oldValue;
        public string newValue;
 
        public ChangeEventArgs(string o, string n)
        {
            oldValue = o;
            newValue = n;
        }
 
        public bool isChanged()
        {
            if (oldValue != newValue) { return true; }
            else { return false; }
        }

29/10/2007, 01h16
SirJulio

Salut,

fais simplement tourner un thread dans ta classe en le bloquant par un AutoResetEvent, dans la methode qui change la valeur en question, tu signales l'event (tu liberes donc le thread de la classe) et tu lances ton event.
29/10/2007, 06h30
fabou3377

Merci d'avoir répondu... Tu peux donner un bout de code comme exemple STP .. Merci

Salut,

desolé de ne pas avoir été plus precis, voici un code reprenant le concept (utilisation de genrics) :

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
    public class Program
    {
        static void Main()
        {
            using (Eventer<string> ev = new Eventer<string>())
            {
                ev.Changed +=
                    delegate(object sender, ChangedEventArgs<string> e)
                    {
                        Console.WriteLine("Changed ! New Value : {0}", e.Value);
                    };
                string s = string.Empty;
                while (s != "q")
                {
                    s = Console.ReadLine();
                    ev.ChangeValue(s);
                }
            }
        }
    }
 
 
    public class Eventer<T> : IDisposable
    {
        static object s_syncO = new object();
 
        AutoResetEvent m_eve;
        Thread m_t;
        bool m_continue;
        bool m_hasChanged;
        T m_data;
 
        public event EventHandler<ChangedEventArgs<T>> Changed;
 
        public Eventer()
        {
            m_continue = true;
            m_eve = new AutoResetEvent(false);
            m_t = new Thread(Idle);
            m_t.Start();
        }
 
        public void ChangeValue(T data)
        {
            lock (s_syncO)
            {
                m_data = data;
                m_hasChanged = true;
                m_eve.Set();
            }
        }
 
 
        void Idle(object state)
        {
            while (m_continue)
            {
                m_eve.WaitOne();
                lock (s_syncO)
                {
                    CheckState();
                }
            }
        }
 
        private void CheckState()
        {
            if (m_hasChanged)
            {
                m_hasChanged = false;
                if (Changed != null)
                {
                    Changed(this, new ChangedEventArgs<T>(m_data));
                }
            }
        }
 
        #region IDisposable Members
 
        public void Dispose()
        {
            m_continue = false;
            m_eve.Set();
            m_t.Join(1000);
            m_eve.Close();
        }
 
        #endregion
    }
 
    public class ChangedEventArgs<T> : EventArgs
    {
        T m_value;
        public T Value
        {
            get { return m_value; }
        }
 
        public ChangedEventArgs(T value)
        {
            m_value = value;
        }
    }

On pourrait aussi utiliser une Queue de changement effectuée, le thread d'event vidant au fur et à mesure cette pile. De meme, on pourrait utiliser la reflection, pour specifier un membre particulier d'une classe. Bref, on peut pas mal optimiser le schmillblik, à toi de voir ce que tu veux en faire.

Bon courage.