Discussion :

[a.floranc]

Bonjour à tous,

Je vous expose mon problème :

J'ai deux classe qui sont des SortableBindingList(of t) qui contiennent donc un nombre x d'une autre classe qui elle même contient donc tout ses éléments.

Je souhaite comparer la première de la deuxième pour en ressortir tout les éléments qui se sont ajouté, mais je souhaite comparer que sur une propriété de mes objets.

J'aimerais évité de créer des boucles du genre for each car il s'agit de comparer deux liste de plus de 40000 objets.

Auriez-vous une direction à me donner ?

Merci d'avance !

[Pol63]

il y a des solutions qui permettent de faire ca en une ligne de code, mais une fois compilé ca sera une boucle quand même au final *
par ailleurs des boucles sur 4000 items ca se fait aussi, ca doit prendre quelques millisecondes ...


* des trucs dans le genre :

Code :

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

dim ajoutés = (from i2 in liste2 where not (from i1 in liste1 select i1.prop).contains(i2.prop) select i2)

[a.floranc]

Merci Pol63

J'ai ecrit ceci :

Code :

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

        Dim Teste = (From T As OutArticle In NewFullFile Where (From U As OutArticle In ActiveOldFullFiles Select U.Reference).Contains(T.Reference) Select T)

Mais cela ne me retourne rien. J'ai essayer pas mal de combinaison mais je n’arrive pas à en sortir une collection.

Du coup j'ai implémenter une boucle mais il faut quand même compter plus d'une minute pour traité les 40000 éléments.

[Pol63]

quel est le type de Reference ?

comme je l'ai dis écrire ca avec du linq est plus court en ligne de code, mais pas souvent plus rapide en temps d'exécution, est-ce que ca mets du temps ici à chercher ?

tu as vérifié le .count ou fait une boucle sur Teste pour dire "ca ne retourne rien" ?



si Reference est la clé de tes items, il te faut un dictionary(of type_de_reference,OutArticle)
et après si tu as DicoOld et DicoNew et pour voir ce qu'il y a de new :

Code :

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

1
2
3
4
5
6
 
  Dim newkeys As IEnumerable(Of type_de_reference) = dicoNew.Keys.Except(dicoOld.Keys)
 
        For Each k As type_de_reference In newkeys ' pour voir le détail de l'objet
            Dim U as OutArticle = dicoNew(k)
        Next

et ca sera instantané

[a.floranc]

En fait J'ai une collection new et old d'élément OutArticle.
Ces éléments OutArticle ont chacun une propriété référence que je veux comparer et environ 70 autres propriété différentes.

En fait pour essayer j'ai mis les références de chacune de mes collection dans deux list(of string). Aprés cela je fais une boucle sur chacune de mes collection et je compare les référence :

Code :

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

1
2
3
4
5
        For Each Art As OutArticle In NewFullFile
            If ListRefOld.IndexOf(Art.Reference) = -1 Then
                NewNewFile.Add(Art)
            End If
        Next

où NewFullFile est une collection d'Article, ListRefOld est la liste des références de la collection Old et NewNewFile mon nouveaux fichier avec les nouvels références.

Pour ton exemple je n'arrive pas à l'implementer, mais il faut dire que je ne suis forcément à l'aise avec tout ces type de collection

[rv26t]

Bonjour,
Et de cette façon?

Code :

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

1
2
3
4
5
        For Each Art As OutArticle In NewFullFile
            If Not (ListRefOld.Contains(Art)) Then
                NewNewFile.Add(Art)
            End If
        Next

A+, Hervé.

[a.floranc]

J'ai essayer, çà fonctionne mais comme il s'agit aussi d'une boucle c'est tout aussi long ! Mais si ta d'autre idées je suis preneur !

[Nathanael Marchand]

J'ai essayer, çà fonctionne mais comme il s'agit aussi d'une boucle c'est tout aussi long ! Mais si ta d'autre idées je suis preneur !

Comparer deux listes sans utiliser de boucles me parait un challenge assez complexe, bon courage

[rv26t]

Dans ce cas il faut voir ça au niveau conceptuel.

Quand tu rajoutes un élément à ta liste "NewFullFile", tu le rajoutes aussi à ta liste "NewNewFile" comme ça plus besoin de comparaison tu as directement tous les nouveaux dans "NewNewFile".

A+, Hervé.

[a.floranc]

Dans ce cas il faut voir ça au niveau conceptuel.

Quand tu rajoutes un élément à ta liste "NewFullFile", tu le rajoutes aussi à ta liste "NewNewFile" comme ça plus besoin de comparaison tu as directement tous les nouveaux dans "NewNewFile".

A+, Hervé.

Effectivement cela peut être un raccourci mais je serait quand même obliger de comparer chacune de mes référence à un fichier old pour peuplé mon "NewNewfile".

Bon c'est un peu long mais ca fonctionne.

Chose intéressante :

Je créer une collection d'article nouveau et supprimé.
Pour gagné du temps j'utilise des backgroudworker qui animent des progressbar.

Au début de l’exécution ont voit nettement les progress bar avancée et petit à petit le processus se ralenti, comme si les boucles devenait de moins en moins rapide.

Savez-vous à quoi cela peut être dû ?

[Pol63]

j'ai fait des tests avec plusieurs techniques, les simples à base de list au bout de 10 seconde j'ai arrêté, la technique avec les dictionnaire prend 50 millisecondes, voici le code:

une classe outarticle en bas avec une propriété référence (et d'autres)
une collection de 50000 outarticle
une collection de 70000 outarticle donc 50000 ayant une référence présente dans la 1ère

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
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
 
Public Class Form1
 
    Dim l1 As New Dictionary(Of String, OutArticle)
    Dim l2 As New Dictionary(Of String, OutArticle)
 
    Sub New()
        InitializeComponent()
 
 
        For i As Integer = 1 To 50000
            Dim o1 As New OutArticle With {.Reference = "AAAA" & i.ToString}
            Dim o2 As New OutArticle With {.Reference = "AAAA" & i.ToString}
 
            l1.Add(o1.Reference, o1)
            l2.Add(o2.Reference, o2)
        Next
 
        For i As Integer = 50001 To 70000
            Dim o2 As New OutArticle With {.Reference = "AAAA" & i.ToString}
            l2.Add(o2.Reference, o2)
        Next
 
 
    End Sub
 
 
 
    Private Sub Form1_Click(sender As Object, e As System.EventArgs) Handles Me.Click
        Dim ch As New System.Diagnostics.Stopwatch
        ch.Start()
 
        Dim nouveaux As New List(Of OutArticle)
 
        Dim newkeys As IEnumerable(Of String) = l2.Keys.Except(l1.Keys)
 
        For Each k As String In newkeys ' pour voir le détail de l'objet
            Dim i As OutArticle = l2(k)
            nouveaux.Add(i)
        Next
 
 
        ch.Stop()
        Me.Text = ch.ElapsedMilliseconds.ToString
    End Sub
 
 
End Class
 
Public Class OutArticle
 
    Public Property Reference As String
 
    Public Property AutreProp As Integer
    '...
 
End Class

nouveaux contient bien 20000 outarticle

le dictionary par rapport aux collections simples permet d'avoir une clé du type qu'on veut, ici la clé est la référence
sur un list(of ) ou autre on peut faire liste(50) pour avoir l'item 50
sur un dictionary on peut faire dico("telle référence") pour accéder à l'item de cette clé (il existe dico.containskey())
le dictionaire hashe les clés, ce qui lui évite de parcourir toute la collection pour trouver l'item de cette clé, il peut faire de la dichotomie permettant un accès rapide

[meziantou]

le dictionary par rapport aux collections simples permet d'avoir une clé du type qu'on veut, ici la clé est la référence
sur un list(of ) ou autre on peut faire liste(50) pour avoir l'item 50
sur un dictionary on peut faire dico("telle référence") pour accéder à l'item de cette clé (il existe dico.containskey())
le dictionaire hashe les clés, ce qui lui évite de parcourir toute la collection pour trouver l'item de cette clé, il peut faire de la dichotomie permettant un accès rapide

J'en profite pour partager un lien sur les différentes Structures de données

[rv26t]

Je vois que d'autres solutions te sont proposées.


Comme j'avais préparé une solution, je te la présente
Mais elle sera surement moins performante que les dictionnaires proposé par Pol63

Il faut une propriété de plus dans ta classe permettant de savoir si c'est un nouveau ou pas

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
33
34
Public Class rechercher
    ' champ
    Private sId As String = "valeur par défaut"
    Private sNouveau As Boolean = False
    'propriété
    Public Property Id() As String
        Get
            Return sId
        End Get
        Set(ByVal value As String)
            sId = value
        End Set
    End Property
    Public Property Nouveau() As Boolean
        Get
            Return sNouveau
        End Get
        Private Set(ByVal value As Boolean)
            sNouveau = value
        End Set
    End Property
 
    ' constructeur de base
    Sub New()
    End Sub
    ' constructeur N°2 avec paramètre
    Sub New(ByVal sUnId As String)
        sId = sUnId
    End Sub
    Sub New(ByVal sUnId As String, ByVal etat As Boolean)
        sId = sUnId
        sNouveau = etat
    End Sub
End Class

remplissage de ta liste + ajout de nouveau

Code :

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

1
2
3
4
5
6
7
8
        Dim rech As New List(Of rechercher)
        ' liste de départ
        rech.Add(New rechercher("un"))
        rech.Add(New rechercher("deux"))
        ' ajout à la liste
        rech.Add(New rechercher("ajouter", True))
 
        Dim listResult As List(Of rechercher) = rech.FindAll(AddressOf existe)

fonction qui permet de déterminer si nouveau ou pas.

Code :

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

1
2
3
    Function existe(ByVal o As rechercher) As Boolean
        Return o.Nouveau
    End Function

listResult ne contiendra que le dernier élément "ajouter".

Mais en interne une boucle est faite donc les temps seront surement long.
Comme Pol63 l'indique la solution avec dictionnaire semble plus adapté.

A+, Hervé.

[a.floranc]

J'en profite pour partager un lien sur les différentes Structures de données

Merci, trés utile !

Merci à tous pour votre aide, je vais essayer tout ça et je vous tient au jus !

Ça y est ! Ça fonctionne au top !

Petit retour d’expérience :

Voici le code de Pol63 adapté à mon cas :

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
33
34
35
36
37
38
        Dim l1 As New Dictionary(Of String, OutArticle)
        Dim l2 As New Dictionary(Of String, OutArticle)
 
 
 
        Dim a As OutArticle
 
        For Each a In ActiveOldFullFiles
            l1.Add(a.Reference, a)
        Next
 
        a = Nothing
 
        For Each a In NewFullFile
            l2.Add(a.Reference, a)
        Next
 
        Dim ch As New System.Diagnostics.Stopwatch
        ch.Start()
 
        Dim nouveaux As New OutArticles
        Dim Ancien As New OutArticles
 
        Dim newkeys As IEnumerable(Of String) = l2.Keys.Except(l1.Keys)
        Dim SupKeys As IEnumerable(Of String) = l1.Keys.Except(l2.Keys)
 
        For Each K As String In newkeys ' pour voir le détail de l'objet
            Dim i As OutArticle = l2(K)
            nouveaux.Add(i)
        Next
 
        For Each L As String In SupKeys ' pour voir le détail de l'objet
            Dim i As OutArticle = l1(L)
            Ancien.Add(i)
        Next
 
        ch.Stop()
        MsgBox(ch.ElapsedMilliseconds.ToString)

Où ActiveOldFullFiles est ma collection d'ancien article et NewFullFile les nouveaux.
Nouveaux et Ancien sont des collections générer des nouveaux articles et des articles supprimé.
Résultat :
67 ms de traitement pour 48339 ancien articles, 49209 nouveaux articles pour un résultat de 3418 articles supprimé et 4288 articles nouveaux .

Super efficace, merci Pol63 et merci aussi aux autre d'avoir contribué à ce gain de performance non négligeable !