Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres et
plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal
'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)
'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot & "];",
, dbForwardOnly)
For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------
Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres et
plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal
'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)
'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot & "];",
, dbForwardOnly)
For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------
Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres et
plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal
'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)
'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot & "];",
, dbForwardOnly)
For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------
Hi,
D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long
Dim MotAnalyser as string
Ensuite :
For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f
Essaies déjà cela...
Christian
"Pascal" a écrit dans le message de news:Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres
et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal
'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)
'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot & "];",
, dbForwardOnly)
For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------
Hi,
D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long
Dim MotAnalyser as string
Ensuite :
For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f
Essaies déjà cela...
Christian
"Pascal" <inconnu@hotmail.com> a écrit dans le message de news:
OVZZVRmCIHA.2268@TK2MSFTNGP02.phx.gbl...
Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres
et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal
'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)
'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot & "];",
, dbForwardOnly)
For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------
Hi,
D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long
Dim MotAnalyser as string
Ensuite :
For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f
Essaies déjà cela...
Christian
"Pascal" a écrit dans le message de news:Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres
et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal
'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)
'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot & "];",
, dbForwardOnly)
For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------
Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal
"Christian Hugoud" a écrit dans le message de
news:Hi,
D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long
Dim MotAnalyser as string
Ensuite :
For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f
Essaies déjà cela...
Christian
"Pascal" a écrit dans le message de news:Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres
et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal
'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)
'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot &
"];", , dbForwardOnly)
For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------
Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal
"Christian Hugoud" <c2h_nospam@couriel.biz> a écrit dans le message de
news: Ob8v9enCIHA.2060@TK2MSFTNGP06.phx.gbl...
Hi,
D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long
Dim MotAnalyser as string
Ensuite :
For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f
Essaies déjà cela...
Christian
"Pascal" <inconnu@hotmail.com> a écrit dans le message de news:
OVZZVRmCIHA.2268@TK2MSFTNGP02.phx.gbl...
Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres
et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal
'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)
'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot &
"];", , dbForwardOnly)
For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------
Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal
"Christian Hugoud" a écrit dans le message de
news:Hi,
D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long
Dim MotAnalyser as string
Ensuite :
For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f
Essaies déjà cela...
Christian
"Pascal" a écrit dans le message de news:Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres
et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal
'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)
'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot &
"];", , dbForwardOnly)
For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------
Oui, mais il faut que microprocesseur convertisse ton byte en long, dans
tous les cas. Il semblerait que ce soit plus rapide de travailler avec des
long, toujours.
"Pascal" a écrit dans le message de news:Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal
"Christian Hugoud" a écrit dans le message de
news:Hi,
D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long
Dim MotAnalyser as string
Ensuite :
For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0
Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f
Essaies déjà cela...
Christian
"Pascal" a écrit dans le message de news:Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres
et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament
que pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal
'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)
'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot &
"];", , dbForwardOnly)
For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------
Oui, mais il faut que microprocesseur convertisse ton byte en long, dans
tous les cas. Il semblerait que ce soit plus rapide de travailler avec des
long, toujours.
"Pascal" <inconnu@hotmail.com> a écrit dans le message de news:
ecpXtxnCIHA.4472@TK2MSFTNGP05.phx.gbl...
Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal
"Christian Hugoud" <c2h_nospam@couriel.biz> a écrit dans le message de
news: Ob8v9enCIHA.2060@TK2MSFTNGP06.phx.gbl...
Hi,
D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long
Dim MotAnalyser as string
Ensuite :
For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0
Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f
Essaies déjà cela...
Christian
"Pascal" <inconnu@hotmail.com> a écrit dans le message de news:
OVZZVRmCIHA.2268@TK2MSFTNGP02.phx.gbl...
Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres
et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament
que pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal
'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)
'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot &
"];", , dbForwardOnly)
For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------
Oui, mais il faut que microprocesseur convertisse ton byte en long, dans
tous les cas. Il semblerait que ce soit plus rapide de travailler avec des
long, toujours.
"Pascal" a écrit dans le message de news:Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal
"Christian Hugoud" a écrit dans le message de
news:Hi,
D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long
Dim MotAnalyser as string
Ensuite :
For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0
Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f
Essaies déjà cela...
Christian
"Pascal" a écrit dans le message de news:Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres
et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament
que pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal
'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)
'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot &
"];", , dbForwardOnly)
For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------
Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des
fois que l'on gagnerai en vitesse ouverture/fermeture table?
Bien à toi
Pascal
"Christian Hugoud" a écrit dans le message de
news:Oui, mais il faut que microprocesseur convertisse ton byte en long, dans
tous les cas. Il semblerait que ce soit plus rapide de travailler avec
des long, toujours.
"Pascal" a écrit dans le message de news:Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal
"Christian Hugoud" a écrit dans le message de
news:Hi,
D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long
Dim MotAnalyser as string
Ensuite :
For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne
scrutes plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0
Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f
Essaies déjà cela...
Christian
"Pascal" a écrit dans le message de news:Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8
lettres et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour
un mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament
que pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal
'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)
'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot &
"];", , dbForwardOnly)
For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------
Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des
fois que l'on gagnerai en vitesse ouverture/fermeture table?
Bien à toi
Pascal
"Christian Hugoud" <c2h_nospam@couriel.biz> a écrit dans le message de
news: eF3J16nCIHA.464@TK2MSFTNGP02.phx.gbl...
Oui, mais il faut que microprocesseur convertisse ton byte en long, dans
tous les cas. Il semblerait que ce soit plus rapide de travailler avec
des long, toujours.
"Pascal" <inconnu@hotmail.com> a écrit dans le message de news:
ecpXtxnCIHA.4472@TK2MSFTNGP05.phx.gbl...
Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal
"Christian Hugoud" <c2h_nospam@couriel.biz> a écrit dans le message de
news: Ob8v9enCIHA.2060@TK2MSFTNGP06.phx.gbl...
Hi,
D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long
Dim MotAnalyser as string
Ensuite :
For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne
scrutes plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0
Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f
Essaies déjà cela...
Christian
"Pascal" <inconnu@hotmail.com> a écrit dans le message de news:
OVZZVRmCIHA.2268@TK2MSFTNGP02.phx.gbl...
Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8
lettres et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour
un mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament
que pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal
'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)
'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot &
"];", , dbForwardOnly)
For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------
Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des
fois que l'on gagnerai en vitesse ouverture/fermeture table?
Bien à toi
Pascal
"Christian Hugoud" a écrit dans le message de
news:Oui, mais il faut que microprocesseur convertisse ton byte en long, dans
tous les cas. Il semblerait que ce soit plus rapide de travailler avec
des long, toujours.
"Pascal" a écrit dans le message de news:Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal
"Christian Hugoud" a écrit dans le message de
news:Hi,
D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long
Dim MotAnalyser as string
Ensuite :
For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne
scrutes plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0
Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f
Essaies déjà cela...
Christian
"Pascal" a écrit dans le message de news:Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8
lettres et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour
un mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament
que pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal
'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)
'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot &
"];", , dbForwardOnly)
For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------
Je ne pense pas car en fait, tu vas juste récupérer l'accès au pointeur.
Faut essayer...
Peut être le InsStr est long ?
"Pascal" a écrit dans le message de news:Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des
fois que l'on gagnerai en vitesse ouverture/fermeture table?
Bien à toi
Pascal
Je ne pense pas car en fait, tu vas juste récupérer l'accès au pointeur.
Faut essayer...
Peut être le InsStr est long ?
"Pascal" <inconnu@hotmail.com> a écrit dans le message de news:
egQDXJoCIHA.2324@TK2MSFTNGP03.phx.gbl...
Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des
fois que l'on gagnerai en vitesse ouverture/fermeture table?
Bien à toi
Pascal
Je ne pense pas car en fait, tu vas juste récupérer l'accès au pointeur.
Faut essayer...
Peut être le InsStr est long ?
"Pascal" a écrit dans le message de news:Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des
fois que l'on gagnerai en vitesse ouverture/fermeture table?
Bien à toi
Pascal
hello,
oui, InsStr est de type Variant (long)
le fait de passer de byte à Long, je gagne effectivement 4/10 secondes
sur l'ensemble(test fait sur mot de 8 lettres)
Autre idée: du fait d'une base ACCESS, je pourrai créer une requête dans
la base et faire appel à celle-ci à partir de VB6! mais comment ajouter le
résultat de ma requête dans un ListView?
Après, je n'ennuie plus personne avec cela!
Bien à toi
Pascal
"Christian Hugoud" a écrit dans le message de
news: %Je ne pense pas car en fait, tu vas juste récupérer l'accès au pointeur.
Faut essayer...
Peut être le InsStr est long ?
"Pascal" a écrit dans le message de news:Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des
fois que l'on gagnerai en vitesse ouverture/fermeture table?
Bien à toi
Pascal
hello,
oui, InsStr est de type Variant (long)
le fait de passer de byte à Long, je gagne effectivement 4/10 secondes
sur l'ensemble(test fait sur mot de 8 lettres)
Autre idée: du fait d'une base ACCESS, je pourrai créer une requête dans
la base et faire appel à celle-ci à partir de VB6! mais comment ajouter le
résultat de ma requête dans un ListView?
Après, je n'ennuie plus personne avec cela!
Bien à toi
Pascal
"Christian Hugoud" <c2h_nospam@couriel.biz> a écrit dans le message de
news: %23nNmV7oCIHA.4476@TK2MSFTNGP06.phx.gbl...
Je ne pense pas car en fait, tu vas juste récupérer l'accès au pointeur.
Faut essayer...
Peut être le InsStr est long ?
"Pascal" <inconnu@hotmail.com> a écrit dans le message de news:
egQDXJoCIHA.2324@TK2MSFTNGP03.phx.gbl...
Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des
fois que l'on gagnerai en vitesse ouverture/fermeture table?
Bien à toi
Pascal
hello,
oui, InsStr est de type Variant (long)
le fait de passer de byte à Long, je gagne effectivement 4/10 secondes
sur l'ensemble(test fait sur mot de 8 lettres)
Autre idée: du fait d'une base ACCESS, je pourrai créer une requête dans
la base et faire appel à celle-ci à partir de VB6! mais comment ajouter le
résultat de ma requête dans un ListView?
Après, je n'ennuie plus personne avec cela!
Bien à toi
Pascal
"Christian Hugoud" a écrit dans le message de
news: %Je ne pense pas car en fait, tu vas juste récupérer l'accès au pointeur.
Faut essayer...
Peut être le InsStr est long ?
"Pascal" a écrit dans le message de news:Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des
fois que l'on gagnerai en vitesse ouverture/fermeture table?
Bien à toi
Pascal
Bien le bonjour,
je cherche à optimiser cette partie de mon code
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
Bien le bonjour,
je cherche à optimiser cette partie de mon code
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
Bien le bonjour,
je cherche à optimiser cette partie de mon code
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
Bien le bonjour,
je cherche à optimiser cette partie de mon code
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
Bien le bonjour,
je cherche à optimiser cette partie de mon code
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
Bien le bonjour,
je cherche à optimiser cette partie de mon code
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
hello,
oui, InsStr est de type Variant (long)
le fait de passer de byte à Long, je gagne effectivement 4/10 secondes sur
l'ensemble(test fait sur mot de 8 lettres)
Autre idée: du fait d'une base ACCESS, je pourrai créer une requête dans la
base et faire appel à celle-ci à partir de VB6! mais comment ajouter le
résultat de ma requête dans un ListView?
hello,
oui, InsStr est de type Variant (long)
le fait de passer de byte à Long, je gagne effectivement 4/10 secondes sur
l'ensemble(test fait sur mot de 8 lettres)
Autre idée: du fait d'une base ACCESS, je pourrai créer une requête dans la
base et faire appel à celle-ci à partir de VB6! mais comment ajouter le
résultat de ma requête dans un ListView?
hello,
oui, InsStr est de type Variant (long)
le fait de passer de byte à Long, je gagne effectivement 4/10 secondes sur
l'ensemble(test fait sur mot de 8 lettres)
Autre idée: du fait d'une base ACCESS, je pourrai créer une requête dans la
base et faire appel à celle-ci à partir de VB6! mais comment ajouter le
résultat de ma requête dans un ListView?