Discussion :

[dacid]

Bonjour @ tous,

J'ai une liste de traitement appelé en //.
Ça fonctionne bien, seulement, j'aimerais passer un booléen à true a la fin de tous ces traitements.
Comment faire pour être sur qu'ils soient tous terminés ?

(je me suis fait une classe afin d'avoir un code plus clair)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Sub Toto()
            ...
            clsAsync.CtrlSetReadOnly(slueDevise, hasLignes) 'slueDevise.Properties.ReadOnly = hasLignes
            clsAsync.CtrlSetEnabled(btnValider, True) 'btnValider.Enabled = True
            clsAsync.CtrlSetEnabled(btnDevalider, False) 'btnDevalider.Enabled = False
            clsAsync.CtrlSetChecked(ckbDocValide, obj.IsValidated) 'ckbDocValide.Checked = obj.IsValidated
            Dim ret As IAsyncResult = clsAsync.CtrlSetReadOnly(btnSave, False) 'btnSave.Enabled = False
            If (Me.InvokeRequired) Then 
                Me.BeginInvoke(New clsAsync.InvokeDelegate(AddressOf SetChanged), False) ' Pour être sur qu'il soit éxecuté après toutes les méthodes asynchrones.
            Else
                 IsChanged = False
            End If
End Sub
 
    Private Sub SetChanged(o As Object)
        IsChanged = CType(o, Boolean)
    End Sub

Car en fait, si un traitement antérieur prend du temps, il est fini après (et met donc ma variable à true).

[lead8209]

Salut, voila la page msdn qui explique le fonctionnement de la méthode Task.WaitAll() qi te permettra d'attendre la fin de toutes tes tâches :
https://msdn.microsoft.com/fr-fr/lib...code-snippet-1

Après vu qu'on a pas le code de lancement on ne sait pas comment tu procèdes pour lancer des tâches. D'ailleurs Task ou Thread ?

A+

[dacid]

Salut Lead,

Merci pour ta réponse.

Bin aucun, c'est juste l'Inkoke du control:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
    Public Shared Function CtrlSetReadOnly(ctl As Control, pValue As Boolean) As IAsyncResult
        If (ctl.InvokeRequired) Then
            Return ctl.BeginInvoke(New ControlSet(AddressOf CtrlSet), ctl, pValue, 0)
        ElseIf (Not ctl.IsDisposed) Then
            CtrlSet(ctl, pValue, 0)
        End If
        Return Nothing
    End Function
 
    Private Shared Sub CtrlSet(ctl As Control, pValue As Object, pMode As Integer)
        CType(ctl, Control).Enabled = CType(pValue, Boolean) 
    End Sub

Et mes appels sont juste au niveau de l’événement OnClick() d'un bouton, pas de thread englobant.

En passant, c'est quoi en gros la différence entre Task et Thread ?

[dacid]

J'ai l'impression que je prends un marteau pilon pour écraser une mouche...
J'ai une classe qui me permet de lancer mes threads, et pour chacun d'eux, je stocke le IAsyncResult dans un tableau

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
Public Class clsAsync
    Private _Results As List(Of IAsyncResult) = New List(Of IAsyncResult)()
    ''' <summary>Mémorise les threads lancés pour avoir leurs états</summary>
    Public Property Results() As List(Of IAsyncResult)
        Get
            Return _Results
        End Get
        Set(ByVal value As List(Of IAsyncResult))
            _Results = value
        End Set
    End Property
 
#Region "Méthodes publiques"
    ''' <summary>Renseigne le texte d'un control</summary>
    ''' <param name="pOpt">0=Remplacer, 1=Ajouter (si StatusStrip=Index de l'item à renseigner).</param>
    Public Function CtrlSetText(ctl As Control, pValue As String, Optional pOpt As Integer = 0) As IAsyncResult
        If (ctl.InvokeRequired) Then
            Dim r As IAsyncResult = ctl.BeginInvoke(New ControlSetStr(AddressOf CtrlAddText), ctl, pValue, pOpt) : _Results.Add(r) : Return r
        ElseIf (Not ctl.IsDisposed) Then
            CtrlAddText(ctl, pValue, pOpt)
        End If
        Return Nothing
    End Function
    Public Function CtrlSetReadOnly(ctl As Control, pValue As Boolean) As IAsyncResult
        If (ctl.InvokeRequired) Then
            Dim r As IAsyncResult = ctl.BeginInvoke(New ControlSet(AddressOf CtrlSet), ctl, pValue, 0) : _Results.Add(r) : Return r
        ElseIf (Not ctl.IsDisposed) Then
            CtrlSet(ctl, pValue, 0)
        End If
        Return Nothing
    End Function
...

Ensuite, dans mon code, je fait mes appels, et à la fin, je boucle sur le fameux tableau pour voir s'ils sont terminés

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
            Asyn.CtrlSetReadOnly(txtTauxDeChange, hasLignes)
            Asyn.CtrlSetReadOnly(cbbAff, hasLignes)
            Asyn.CtrlSetReadOnly(cbbTiersLiv, hasLignes)
            Asyn.CtrlSetReadOnly(cbbDevise, hasLignes)
...
            Dim passe As Boolean = True
            Do
                passe = True
                setMsg($"Début passage de vérification de fin des threads")
                For i As Integer = 0 To Asyn.Results.Count - 1
                    'If (Not Asyn.Results(i).IsCompleted) Then passe = False : setMsg($"Taches parallèles: {Asyn.Results(i)} non terminé.")
                Next
                setMsg($"Fin passage de vérification de fin des threads")
            Loop Until passe
            Asyn.Results.Clear()
            setMsg($"Ok, tout est terminé")

Mais plus ça va, plus le Asyn.Results grandit.
Au premier passage, il y a genre 30 éléments (normal), dont 20 de non terminés.
Au deuxième passage, il y en a 37, dont 2 de non terminés, ok.
Mais après, il y en a de plus en plus et de façon exponentielle, genre 42000, et de plus en plus de non terminés.
Je ne doit pas m'y prendre de la bonne manière...

Quelqu'un a t'il une idée, j'ai du mal à trouver des cas de figure ou il y a des beginInvoke en lot.

Merci d'avance.