InvalidOperationException VB.NET WPF

Signaler
Messages postés
41
Date d'inscription
mercredi 22 juin 2011
Statut
Membre
Dernière intervention
22 juillet 2012
-
Messages postés
41
Date d'inscription
mercredi 22 juin 2011
Statut
Membre
Dernière intervention
22 juillet 2012
-
Bonjour,

J'ai une application qui tourne 24h sur 24...
Elle plante régulièrement, après une journée des fois deux jours complétement aléatoirement.

Je la laisse tourner en debug pour savoir qu'elle est le soucie.

J'ai une exception: InvalidOperationException La collection a été modifiée; l’opération d’énumération peut ne pas s’exécuter

Je ne sais pas ou chercher dans mon programme.

J'ai plusieurs thread, par exemple un qui fait le rafraichissement de toute les variables tout les secondes qui serve pour l'application.

Chaque thread et un singleton, chaque sub de mes thread sont protéger pour éviter l’accé concurrentiel.

J'aimerais connaitre la méthode pour trouver la localisation de l'erreur.

Qu'elle sont les points important à vérifier pour cette exception ?

Merci de votre aide.
A voir également:

13 réponses


Bonjour,

Tu tentes sûrement de supprimer ou d'ajouter un élément à une collection à l'intérieur d'une boucle d'énumération des éléments de cette collection.
Tu devrais placer le mot clé 'Stop' dans la boucle suspectée et exécuter ensuite en pas à pas (F8) pour observer le comportement du code.
Messages postés
41
Date d'inscription
mercredi 22 juin 2011
Statut
Membre
Dernière intervention
22 juillet 2012

Bonjour,

justement j'ai mis chaque boucle dans des Try Cast qui ecrive dans des fichiers texte pour localiser l'endroit ou sa coince.

après plusieurs semaine de test et plusieurs plantage, aucun de mes Try Cast on ecrit dans mes fichier text de localisation du probléme.

voici le message d'erreur de plantage si sa peut aider:



à System.ThrowHelper.ThrowInvalidOperationException(ExceptionResource resource)
à System.Collections.Generic.List`1.Enumerator.MoveNextRare()
à System.Collections.Generic.List`1.Enumerator.MoveNext()
à System.Windows.Data.CollectionView..ctor(IEnumerable collection, Int32 moveToFirst)
à System.Windows.Data.ListCollectionView..ctor(IList list)
à MS.Internal.Data.ViewManager.GetViewRecord(Object collection, CollectionViewSource cvs, Type collectionViewType, Boolean createView)
à MS.Internal.Data.DataBindEngine.GetViewRecord(Object collection, CollectionViewSource key, Type collectionViewType, Boolean createView)
à System.Windows.Data.CollectionViewSource.GetDefaultCollectionView(Object source, Boolean createView)
à System.Windows.Data.CollectionViewSource.GetDefaultCollectionView(Object source, DependencyObject d)
à System.Windows.Controls.ItemCollection.SetItemsSource(IEnumerable value)
à System.Windows.Controls.ItemsControl.OnItemsSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
à System.Windows.DependencyObject.OnPropertyChanged(DependencyPropertyChangedEventArgs e)
à System.Windows.FrameworkElement.OnPropertyChanged(DependencyPropertyChangedEventArgs e)
à System.Windows.DependencyObject.NotifyPropertyChange(DependencyPropertyChangedEventArgs args)
à System.Windows.DependencyObject.UpdateEffectiveValue(EntryIndex entryIndex, DependencyProperty dp, PropertyMetadata metadata, EffectiveValueEntry oldEntry, EffectiveValueEntry& newEntry, Boolean coerceWithDeferredReference, Boolean coerceWithCurrentValue, OperationType operationType)
à System.Windows.DependencyObject.InvalidateProperty(DependencyProperty dp)
à System.Windows.Data.BindingExpressionBase.Invalidate(Boolean isASubPropertyChange)
à System.Windows.Data.BindingExpression.TransferValue(Object newValue, Boolean isASubPropertyChange)
à System.Windows.Data.BindingExpression.Activate(Object item)
à System.Windows.Data.BindingExpression.OnDataContextChanged(DependencyObject contextElement)
à System.Windows.Data.BindingExpression.HandlePropertyInvalidation(DependencyObject d, DependencyPropertyChangedEventArgs args)
à System.Windows.Data.BindingExpressionBase.OnPropertyInvalidation(DependencyObject d, DependencyPropertyChangedEventArgs args)
à System.Windows.Data.BindingExpression.OnPropertyInvalidation(DependencyObject d, DependencyPropertyChangedEventArgs args)
à System.Windows.DependentList.InvalidateDependents(DependencyObject source, DependencyPropertyChangedEventArgs sourceArgs)
à System.Windows.DependencyObject.NotifyPropertyChange(DependencyPropertyChangedEventArgs args)
à System.Windows.DependencyObject.UpdateEffectiveValue(EntryIndex entryIndex, DependencyProperty dp, PropertyMetadata metadata, EffectiveValueEntry oldEntry, EffectiveValueEntry& newEntry, Boolean coerceWithDeferredReference, Boolean coerceWithCurrentValue, OperationType operationType)
à System.Windows.DependencyObject.InvalidateProperty(DependencyProperty dp)
à System.Windows.Data.BindingExpressionBase.Invalidate(Boolean isASubPropertyChange)
à System.Windows.Data.BindingExpression.TransferValue(Object newValue, Boolean isASubPropertyChange)
à System.Windows.Data.BindingExpression.ScheduleTransfer(Boolean isASubPropertyChange)
à MS.Internal.Data.ClrBindingWorker.NewValueAvailable(Boolean dependencySourcesChanged, Boolean initialValue, Boolean isASubPropertyChange)
à MS.Internal.Data.PropertyPathWorker.UpdateSourceValueState(Int32 k, ICollectionView collectionView, Object newValue, Boolean isASubPropertyChange)
à MS.Internal.Data.ClrBindingWorker.ScheduleTransferOperation(Object arg)
à System.Windows.Threading.ExceptionWrapper.InternalRealCall(Delegate callback, Object args, Int32 numArgs)
à MS.Internal.Threading.ExceptionFilterHelper.TryCatchWhen(Object source, Delegate method, Object args, Int32 numArgs, Delegate catchHandler)
à System.Windows.Threading.DispatcherOperation.InvokeImpl()
à System.Windows.Threading.DispatcherOperation.InvokeInSecurityContext(Object state)
à System.Threading.ExecutionContext.runTryCode(Object userData)
à System.Runtime.CompilerServices.RuntimeHelpers.ExecuteCodeWithGuaranteedCleanup(TryCode code, CleanupCode backoutCode, Object userData)
à System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state)
à System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean ignoreSyncCtx)
à System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
à System.Windows.Threading.DispatcherOperation.Invoke()
à System.Windows.Threading.Dispatcher.ProcessQueue()
à System.Windows.Threading.Dispatcher.WndProcHook(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam, Boolean& handled)
à MS.Win32.HwndWrapper.WndProc(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam, Boolean& handled)
à MS.Win32.HwndSubclass.DispatcherCallbackOperation(Object o)
à System.Windows.Threading.ExceptionWrapper.InternalRealCall(Delegate callback, Object args, Int32 numArgs)
à MS.Internal.Threading.ExceptionFilterHelper.TryCatchWhen(Object source, Delegate method, Object args, Int32 numArgs, Delegate catchHandler)
à System.Windows.Threading.Dispatcher.InvokeImpl(DispatcherPriority priority, TimeSpan timeout, Delegate method, Object args, Int32 numArgs)
à MS.Win32.HwndSubclass.SubclassWndProc(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam)
à MS.Win32.UnsafeNativeMethods.DispatchMessage(MSG& msg)
à System.Windows.Threading.Dispatcher.PushFrameImpl(DispatcherFrame frame)
à System.Windows.Threading.Dispatcher.PushFrame(DispatcherFrame frame)
à System.Windows.Application.RunDispatcher(Object ignore)
à System.Windows.Application.RunInternal(Window window)
à System.Windows.Application.Run(Window window)
à System.Windows.Application.Run()
à Hyperion.Application.Main() dans C:\Users\Hyperion\Desktop\Hyperion - New 5\Hyperion\obj\x86\Debug\Application.g.vb:ligne 76
à System.AppDomain._nExecuteAssembly(RuntimeAssembly assembly, String[] args)
à System.AppDomain.ExecuteAssembly(String assemblyFile, Evidence assemblySecurity, String[] args)
à Microsoft.VisualStudio.HostingProcess.HostProc.RunUsersAssembly()
à System.Threading.ThreadHelper.ThreadStart_Context(Object state)
à System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean ignoreSyncCtx)
à System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
à System.Threading.ThreadHelper.ThreadStart()

Il y a une indication peut-être utile :
à Hyperion.Application.Main() dans C:\Users\Hyperion\Desktop\Hyperion - New 5\Hyperion\obj\x86\Debug\Application.g.vb:ligne 76
A voir...
Sinon, tu peux placer des points d'arrêts (F9) ou des messages debug avant et après tes boucles. Si l'exécution du code n'arrive pas au second point d'arrêt, tu trouveras la boucle défectueuse.
Messages postés
41
Date d'inscription
mercredi 22 juin 2011
Statut
Membre
Dernière intervention
22 juillet 2012

en générale tout le programme fonctionne bien pendant facilement 24h voir 48h des fois moins, et tout les routines sont en (try cast)
ayant des thread qui s’effectue tout les secondes, la plantage devrait arriver tout suite mes ces complétements aléatoires, avec aucun événement en particulier qui pourrai générai se bug.

l'indication (C:\Users\Hyperion\Desktop\Hyperion - New 5\Hyperion\obj\x86\Debug\Application.g.vb:ligne 76) est générer par le compilateur, ce n'est pas une page que j'ai développé.

Je vais essayer en debug mes le fait d'avoir plusieurs thread risque de perturber les points d’arrêt ?

Je vais déjà chercher autour de cette piste, merci pour l'aide.

si tu a d'autre idées hésite pas...

Si c'est le cas, il faut éviter les énumérations avec For Each lorsqu'on désire ajouter ou supprimer des éléments dans une collection.
Utilise plutot For ... Next avec une gestion de l'indice lors d'une suppression ou d'un ajout.
Quoi qu'il en soit, il faut éviter de modifier une collection pendant qu'on est en train de l'énumérer.
Messages postés
41
Date d'inscription
mercredi 22 juin 2011
Statut
Membre
Dernière intervention
22 juillet 2012

Je fait un test en désactivant les For Each qui me semble dangereux, pour voire si sa plante encore, si c'est le cas alors je ferais des For Next,

Le For Next est différent du For Each ?

For Each énumèrera absolument tous les éléments donc si tu supprimes l'un d'entre eux, tu obtiendras l'erreur :
La collection a été modifiée ; l'opération d'énumération peut ne pas s'exécuter.

For Next est plus souple puisque tu peux agir sur l'index pour reprendre l'énumération au bon endroit et sans provoquer d'erreur.
Messages postés
41
Date d'inscription
mercredi 22 juin 2011
Statut
Membre
Dernière intervention
22 juillet 2012

L'application n'a pas planté depuis 24h je laisse encore tourner 48h et je met en place des For Next.

Un grand merci pour ton aide.

Je te tien au courant si sa marche.
Messages postés
41
Date d'inscription
mercredi 22 juin 2011
Statut
Membre
Dernière intervention
22 juillet 2012

Salut,

Alors le problème viens d'une routine, que j'ai réussi à localiser

Principe de fonctionnement, je récupère l’état des alarmes dans un fichier binary et leur état dans l'automate, je compare les liste pour savoir
qu'elle sont les défaut qui apparaisse et disparaisse.

A coter je récupère aussi la liste des défauts qui sont actif avec leur affichage dans une listView.



j'ai desactiver la function TraitementAlarme() est je n'est plus le bug de mon application, mes je n'est plus la gestion des alarmes sur mon applications.

Je développe de façon autodidacte, je n'est peut être pas la bonne façon de travailler, mes il faut absolument que je répare, Merci ce bug.

Si tu a des pistes pour m'aider je suis preneur, Merci.

Routine sens la correction avec les (For Each):

'a refaire avec des for next
    '/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    '///////////////////////////Crée la liste des etat d'alarme avec l'automate///////////////////////////////////////////////
    Private Sub TraitementAlarme()

        LectureEtatAlarmeFichier()
        LectureEtatAlarmeAutomate()

        Dim testListe As Boolean = False
        '        Dim listID As List(Of Int64) = New List(Of Int64)   'Liste des Id qui ont eu un changement d'etat
        Dim listID As New List(Of EtatAlarme)   'Liste des Id qui ont eu un changement d'etat

        Try ' A enlever pour test programme
            For Each elementF As EtatAlarme In ListEtatAlarmeFichier
                For Each elementA As EtatAlarme In ListEtatAlarmeAutomate
                    If (elementF.id = elementA.id) Then
                        If Not (elementF.etat = elementA.etat) Then
                            '                        listID.Add(elementA.id) 'charge la liste des Id qui on eu un changement d'etat
                            listID.Add(elementA) 'charge la liste des Id qui on eu un changement d'etat
                        End If
                    End If
                Next
            Next
        Catch ex As Exception ' A enlever pour test programme
            FileError("WatchVariable / TraitementAlarme / For Each elementF") ' A enlever pour test programme
        End Try ' A enlever pour test programme

        Try
            For Each elementId As EtatAlarme In listID   'pour chaque Id qui a etait modifier 
                '            For Each elementId As Int64 In listID   'pour chaque Id qui a etait modifier 
                'For Each elementA As EtatAlarme In ListEtatAlarmeAutomate
                'If (elementId = elementA.id) Then
                If (elementId.etat = True) Then  'front montant sur l'etat du defaut
                    Dim appa As LogAlarme = New LogAlarme 'faire apparition attention fichier logalarme
                    appa.id = elementId.id
                    appa.apparition = DateTime.Now
                    LogAlarmes.WriteFileBinaryApparition("Alarme", appa)    'Ecriture dans le fichier de l'apparition du defaut
                End If
                If (elementId.etat = False) Then 'front descendant sur l'etat du defaut
                    Dim dispa As LogAlarme = New LogAlarme
                    dispa.id = elementId.id
                    dispa.disparition = DateTime.Now
                    LogAlarmes.WriteFileBinaryDisparition("Alarme", dispa)  'Ecriture dans le fichier binaire de la disparition du defaut
                End If
                '                End If
            Next
            '            Next
        Catch ex As Exception
            System.Console.Out.WriteLine(ex.Message)
            FileError("WatchVariable / TraitementAlarme / For Each elementID") ' A enlever pour test programme
        End Try

    End Sub













Routine avec les (For Next) :

 'a refaire avec des for next
    '/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    '///////////////////////////Crée la liste des etat d'alarme avec l'automate///////////////////////////////////////////////
    Private Sub TraitementAlarme()

        LectureEtatAlarmeFichier() 'Lecture des alarmes dans un fichier binary (rempli un list utiliser si dessous disponible pour tout le classe
        LectureEtatAlarmeAutomate()'Lecture des alarmes dans l'automate (rempli un list utiliser si dessous disponible pour tout le classe

'je compare les lists entre mon fichier binaire et l'automate pour savoir qu'elle sont les defauts (alarmes) qui on changer d'etat


        Dim testListe As Boolean = False
        Dim listID As New List(Of EtatAlarme)   'Liste des Id qui ont eu un changement d'etat

        Try ' A enlever pour test programme

            Dim nbr1 As Int64 = ListEtatAlarmeFichier.Count - 1
            For debut1 = 0 To nbr1 Step 1
                If (Not ListEtatAlarmeFichier.Count - 1 = nbr1) Then
                    Exit For
                End If
                Dim nbr2 As Int64 = ListEtatAlarmeAutomate.Count - 1
                For debut2 = 0 To nbr2 Step 1
                    If (Not ListEtatAlarmeAutomate.Count - 1 = nbr2) Then
                        Exit For
                    End If
                    If (Not ListEtatAlarmeFichier.Count - 1 = nbr1) Then
                        Exit For
                    End If

                    Try
                        Dim etat1 As New EtatAlarme
                        Dim etat2 As New EtatAlarme
                        etat1 = ListEtatAlarmeFichier.ElementAt(debut1)
                        etat2 = ListEtatAlarmeAutomate.ElementAt(debut2)
                        If (etat1.id = etat2.id) Then
                            If Not (etat1.etat = etat2.etat) Then
                                listID.Add(etat2)
                            End If
                        End If
                    Catch ex As Exception
                        Exit For
                    End Try
                Next
            Next
        Catch ex As Exception ' A enlever pour test programme
            FileError("WatchVariable / TraitementAlarme / For Each elementF") ' A enlever pour test programme
        End Try ' A enlever pour test programme

        Try
            For Each elementId As EtatAlarme In listID   'pour chaque Id qui a etait modifier                 
                If (elementId.etat = True) Then  'front montant sur l'etat du defaut
                    Dim appa As LogAlarme = New LogAlarme 'faire apparition attention fichier logalarme
                    appa.id = elementId.id
                    appa.apparition = DateTime.Now
                    LogAlarmes.WriteFileBinaryApparition("Alarme", appa)    'Ecriture dans le fichier de l'apparition du defaut
                End If
                If (elementId.etat = False) Then 'front descendant sur l'etat du defaut
                    Dim dispa As LogAlarme = New LogAlarme
                    dispa.id = elementId.id
                    dispa.disparition = DateTime.Now
                    LogAlarmes.WriteFileBinaryDisparition("Alarme", dispa)  'Ecriture dans le fichier binaire de la disparition du defaut
                End If

            Next

        Catch ex As Exception
            System.Console.Out.WriteLine(ex.Message)
            FileError("WatchVariable / TraitementAlarme / For Each elementID") ' A enlever pour test programme
        End Try

    End Sub








A coter j'ai un autre routine qui recupere les defauts qui sont actif dans l'automate pour les affichers dans une listview:




  Private Sub LectureAlarmeActif()
        ListeAlarmeActif = New WpfObservableCollection(Of LogAlarme) 'wpf
        ' ListeAlarmeActif = New ObservableCollection(Of LogAlarme)

        Dim alarmeactif As LogAlarme
        Dim theConfig As ConfigMgt = New ConfigMgt

        Try ' A enlever pour test programme
            ListeAlarmeActif.Clear()
            For Each element As EtatAlarme In ListEtatAlarmeAutomate
                If (element.etat = True) Then   'seulement si l'alarmes et active
                    alarmeactif = New LogAlarme
                    alarmeactif.id = element.id
                    theConfig = ConfigMgt.GetInstance()     'Lance l'instance pour faire la lecture de l'XML
                    For Each def As DefautAutomate In theConfig.Defauts
                        If (element.id = def.Id) Then
                            alarmeactif.defaut = def.Description    'Charge le nom du defaut
                        End If
                    Next
                    ListeAlarmeActif.Add(alarmeactif)
                End If
            Next
        Catch ex As Exception ' A enlever pour test programme
            FileError("WatchVariable / LectureAlarmeActif / For Each element") ' A enlever pour test programme
        End Try ' A enlever pour test programme

    End Sub

Je ne sais rien de ton application notamment la structure de tes classes EtatAlarme, LogAlarme ou DefautAutomate.

Quelles informations sur ces alarmes récupères-tu depuis ce fichier binaire ?
Qui décide de la lecture de ces fichiers ? Un utilisateur ? Un intervalle de temps défini ?
As-tu réellement besoin d'énumérer ces alarmes ?
Y-a-t-il la possibilité de mettre des événements dans tes classes ? Ce qui te permettrait de te passer des boucles d'énumération.

Donne un peu plus d'information s'il te plaît
Messages postés
41
Date d'inscription
mercredi 22 juin 2011
Statut
Membre
Dernière intervention
22 juillet 2012

Oui, j'ai été trop vite dans mon poste.

Alors EtatAlarme et simplement (une variable int64 du non de ID et une variable boolean du non de ETAT)
l'ID correspond a l'identifiant du defaut (correspond a un string dans le fichier de conf xml , description)
l'ETAT correspond a l'etat du defaut actif ou non actif.

Dans le fichier binaire je récupère pour chaque ID qui est dans le fichier de conf la valeur de l'ETAT
Je fait la même chose dans l'automate pour chaque ID je récupère l'ETAT
Ensuite je compare ces liste pour savoir si un defaut a apparut ou disparu en fonction de cela, je viens écrire ou modifier le fichier binaire.
Le fichier binaire me sert de base de donnée fait maison pour historiser les alarmes

L’exécution de ma classe qui contient les plusieurs fonction de gestion d'alarme s’exécute toute les secondes.
Cette classe est soumis a un thread et un singleton.


La classe LogAlarme, contient tout les routine qui vienne traiter le fichier binaire.
-Écriture apparition de défaut
-Modification quand disparition défaut
-Parcours du fichier pour récupère la liste des ID et leur ETAT
les routines sont appeler dans la classe ou j'ai le problème


DefautAutomate et le type qui sert à identifier un defaut dans le fichier de conf.
 <DefautAutomate>
      <Description>RoofTop1</Description>
      Roof1SyntheseAlarme
      8
    </DefautAutomate>



je suis obliger d’énumérer a chaque secondes pour toujours connaitre l’état des alarmes.


je cherche sans vraiment trouver de solutions.

Merci pour ton aide.

Je n'ai pas bien compris si l'automate écrit un fichier xml ?
Ecrit-il ce fichier dès qu'il se produit une erreur ou l'écrit-il à intervalle régulier ?
Messages postés
41
Date d'inscription
mercredi 22 juin 2011
Statut
Membre
Dernière intervention
22 juillet 2012

Alors en gros le fichier xml (conf.xml dans mon application)
Sert à configurer mon application, je déclare les défauts dans ce fichier de conf.

chaque défaut qui est déclarer dans mon fichier de conf.xml est parcouru dans l'automate et dans le fichier binaire pour connaitre l’état des alarmes

Le fichier de conf et parcouru de façon régulière pour récupéré tout les alarmes qui existe.

Le fichier de conf.xml ne bouge jamais sauf si moi je viens le paramétré manuellement pour modifier mon application par exemple si je rajoute un nouveaux défauts.

l'automate n’écrit rien sur l'ordinateur pour éviter de compliquer l'application, je récupère ou écrit simplement l'etat de tout les variables dans l'automate via un protocole pour que mon application puisse paramétré l'automate ou visualiser ce qui se passe dans l'automate.


Donc pour revenir a ta question, le thread s'effectue toute les secondes.


Je récupère dans l'automate l’état de tout les alarmes qui sont déclarer dans le fichier conf.xml

ListEtatAlarmeAutomate:
ID=1 ETAT=1
ID=2 ETAT=1
ID=3 ETAT=0
ID=4 ETAT=0
ID=5 ETAT=1
ID=6 ETAT=0
ID=7 ETAT=1

Je récupère l’état des alarmes dans le fichier binaire qui me sert de base de donnée

ListEtatAlarmeFichier:
ID=1 ETAT=0
ID=2 ETAT=1
ID=3 ETAT=1
ID=4 ETAT=0
ID=5 ETAT=1
ID=6 ETAT=0
ID=7 ETAT=1


Ensuite je compare les deux liste, et je récupère les alarmes qui on changer d’état dans un nouvelle liste.

ID=1 ETAT=0
ID=3 ETAT=1


Si cette liste est vierge il ne se passe rien par contre dans notre cas deux alarmes on changer d’état, donc il faut archiver ce changement d’état dans le fichier binaire(base de donnée)

je parcourt cette nouvelle liste.

Si Etat=0 le défaut a disparu je viens modifier le fichier binaire en modifiant la date et l'heure de disparition
Si Etat=1 je vien ecrire l'apparition d'un nouveaux defaut a la suite du fichier binaire
les fonctions qui vienne toucher au fichier binaire sont dans la classe LogAlarme

Sa permet d'historiser chaque defaut qui apparait et chaque defaut qui disparait dans le fichier binaire pour avoir un suivie
le fichier binaire et organiser comme sa:
ID du defaut / Date Apparition / Date disparition
ID du defaut / Date Apparition / Date disparition
ID du defaut / Date Apparition / Date disparition
ID du defaut / Date Apparition / Date disparition
ID du defaut / Date Apparition / Date disparition
ID du defaut / Date Apparition / Date disparition
Exemple:
1 / 120722112500 / 0 Le defaut na pas encore disparu et donc il est actif
3 / 120722112500 / 120722112600 Le defaut a disparu et donc il est non actif


Dans notre cas le defaut ID 1 et 3
Vont etre modifier dans le fichier binaire. on reviens a notre list:
ID=1 ETAT=0 appel routine disparition
ID=3 ETAT=1 appel routine apparition

cela donne dans le fichier binaire:
1 / 120722112500 / 120722112700
3 / 120722112500 / 120722112600
3 / 120722112800 / 0

pour info: 120722112800 = 2012/07/22 11:28:00

Donc chaque seconde on regarde la listEtatAlarmeAutomate et la ListEtatAlarmeFichier on les compares, on récupère la nouvelle list et on modifie le fichier binaire, si la nouvelle list recupere est vierge il se passe rien.

J'ai beaucoup de mal a m'expliquer par écrit , désoler

Merci.