Bonjour tout le monde,
J'ai besoin de transformer un chemin UNC en chemin basé sur une lettre
de lecteur (à charge pour l'utilisateur de l'avoir défini avant).
Je pars de l'exemple All drives de
http://allapi.mentalis.org/apilist/GetLogicalDriveStrings.shtml, dans
un module standard, et j'ajoute ce qui suit (quelques fonctions ne
sont plus utilisées).
Dites-moi voir si on peut faire mieux.
====================================================== >
Public Function UNCenLettre(strUNC As String) As String
Dim strTmp As String
Dim strChemins() As String
Dim strAllDrives As String
Dim N As Integer, Nb As Integer
strAllDrives = fGetDrives
Do
ReDim Preserve strChemins(1, N)
strTmp = Mid$(strAllDrives, 1, InStr(strAllDrives,
vbNullChar) - 1)
strChemins(0, N) = strTmp
If GetDriveType(Left$(strTmp, 2)) = DRIVE_REMOTE Then
strChemins(1, N) > JusqueZero(fGetUNCPath(Left$(strTmp, 2)))
End If
strAllDrives = Mid$(strAllDrives, InStr(strAllDrives,
vbNullChar) + 1)
N = N + 1
Loop While Not strAllDrives = ""
Nb = UBound(strChemins, 2)
For N = 0 To Nb - 1
'Debug.Print strChemins(0, N) + " | " + strChemins(1, N)
If Left$(strUNC, Len(strChemins(1, N))) = strChemins(1, N) And
Len(strChemins(1, N)) > 0 Then
UNCenLettre = strChemins(0, N) + Right$(strUNC, Len(strUNC) -
Len(strChemins(1, N)))
End If
Next
If Len(UNCenLettre) = 2 Then UNCenLettre = UNCenLettre + ""
End Function
'________
Public Function JusqueZero(strIn As String) As String
Dim I As Integer
I = InStr(strIn, Chr$(0))
JusqueZero = Left$(strIn, I - 1)
End Function
Bonjour tout le monde,
J'ai besoin de transformer un chemin UNC en chemin basé sur une lettre
de lecteur (à charge pour l'utilisateur de l'avoir défini avant).
Je pars de l'exemple All drives de
http://allapi.mentalis.org/apilist/GetLogicalDriveStrings.shtml, dans
un module standard, et j'ajoute ce qui suit (quelques fonctions ne
sont plus utilisées).
Dites-moi voir si on peut faire mieux.
====================================================== >
Public Function UNCenLettre(strUNC As String) As String
Dim strTmp As String
Dim strChemins() As String
Dim strAllDrives As String
Dim N As Integer, Nb As Integer
strAllDrives = fGetDrives
Do
ReDim Preserve strChemins(1, N)
strTmp = Mid$(strAllDrives, 1, InStr(strAllDrives,
vbNullChar) - 1)
strChemins(0, N) = strTmp
If GetDriveType(Left$(strTmp, 2)) = DRIVE_REMOTE Then
strChemins(1, N) > JusqueZero(fGetUNCPath(Left$(strTmp, 2)))
End If
strAllDrives = Mid$(strAllDrives, InStr(strAllDrives,
vbNullChar) + 1)
N = N + 1
Loop While Not strAllDrives = ""
Nb = UBound(strChemins, 2)
For N = 0 To Nb - 1
'Debug.Print strChemins(0, N) + " | " + strChemins(1, N)
If Left$(strUNC, Len(strChemins(1, N))) = strChemins(1, N) And
Len(strChemins(1, N)) > 0 Then
UNCenLettre = strChemins(0, N) + Right$(strUNC, Len(strUNC) -
Len(strChemins(1, N)))
End If
Next
If Len(UNCenLettre) = 2 Then UNCenLettre = UNCenLettre + ""
End Function
'________
Public Function JusqueZero(strIn As String) As String
Dim I As Integer
I = InStr(strIn, Chr$(0))
JusqueZero = Left$(strIn, I - 1)
End Function
Bonjour tout le monde,
J'ai besoin de transformer un chemin UNC en chemin basé sur une lettre
de lecteur (à charge pour l'utilisateur de l'avoir défini avant).
Je pars de l'exemple All drives de
http://allapi.mentalis.org/apilist/GetLogicalDriveStrings.shtml, dans
un module standard, et j'ajoute ce qui suit (quelques fonctions ne
sont plus utilisées).
Dites-moi voir si on peut faire mieux.
====================================================== >
Public Function UNCenLettre(strUNC As String) As String
Dim strTmp As String
Dim strChemins() As String
Dim strAllDrives As String
Dim N As Integer, Nb As Integer
strAllDrives = fGetDrives
Do
ReDim Preserve strChemins(1, N)
strTmp = Mid$(strAllDrives, 1, InStr(strAllDrives,
vbNullChar) - 1)
strChemins(0, N) = strTmp
If GetDriveType(Left$(strTmp, 2)) = DRIVE_REMOTE Then
strChemins(1, N) > JusqueZero(fGetUNCPath(Left$(strTmp, 2)))
End If
strAllDrives = Mid$(strAllDrives, InStr(strAllDrives,
vbNullChar) + 1)
N = N + 1
Loop While Not strAllDrives = ""
Nb = UBound(strChemins, 2)
For N = 0 To Nb - 1
'Debug.Print strChemins(0, N) + " | " + strChemins(1, N)
If Left$(strUNC, Len(strChemins(1, N))) = strChemins(1, N) And
Len(strChemins(1, N)) > 0 Then
UNCenLettre = strChemins(0, N) + Right$(strUNC, Len(strUNC) -
Len(strChemins(1, N)))
End If
Next
If Len(UNCenLettre) = 2 Then UNCenLettre = UNCenLettre + ""
End Function
'________
Public Function JusqueZero(strIn As String) As String
Dim I As Integer
I = InStr(strIn, Chr$(0))
JusqueZero = Left$(strIn, I - 1)
End Function
Hello,
je ne sais pas si on peut faire "mieux", car il faudrait au préalabal e
donner une définition consensuelle de la notion de "mieux", ce qui n' est
pas gagné d'avance et pourrait sans nul doute occuper ce forum pendan t
des semaines :-)
Hello,
je ne sais pas si on peut faire "mieux", car il faudrait au préalabal e
donner une définition consensuelle de la notion de "mieux", ce qui n' est
pas gagné d'avance et pourrait sans nul doute occuper ce forum pendan t
des semaines :-)
Hello,
je ne sais pas si on peut faire "mieux", car il faudrait au préalabal e
donner une définition consensuelle de la notion de "mieux", ce qui n' est
pas gagné d'avance et pourrait sans nul doute occuper ce forum pendan t
des semaines :-)
Jean-marc a écrit, le 17/07/2007 22:11 :Hello,
Que voilà pourtant des conseils précieux.
Le N était une réminiscence du GWbasic, comme quoi, quand on est
dynosaure, de nos jours, il faut s'adapter ...
Le coup du ByVal, il m'est arrivé la semaine dernière d'être obligé de
le mettre, sinon ça plantait juste à cause de ça. Sinon, c'est vrai
que j'ai un peu une fâcheuse tendance à négliger ça.
Je mets toujours vbCrLf plutôt que chr$(13) + chr$(10), mais le
vbNullChar je ne l'avais pas en tête. Je devrais me mettre à jour
là-dessus aussi. A ce que j'ai entendu c'est un motif de se faire
rétamer par la moulinette de conversion automatique de VB6 vers VB.Net
Ah, oui, le coup de stocker un calcul intermédiaire dans une variable
avant de s'en servir plusieurs fois, quelqu'un (peut-être toi) m'en
avait parlé il y a un an ou deux. ça va bien finir par entrer.
J'entendais bien une idée qui me rôdait dans la tête, aussi, quand
j'ai tapé ça :)
Ah, oui, l'indentation, jamais moyen de savoir à l'avance comment elle
sera faite ici. J'aurais bien guetté la parution pour voir comment ça
sortait, et puis je l'ai découverte en même temps que ta réponse.
C'est vrai que mettre une condition dans une variable booléenne ça
allège la syntaxe, mais alors il faut veiller à l'initialiser au bon
endroit. Souvent, une fois avant la boucle, et une fois à la fin
(surtout pour un While).
C'est vrai que les commentaires c'est un truc auquel on pense parfois
un peu tard. Ce matin, j'ai réalisé que je n'ai même pas écrit dans
mon module pourquoi je l'ai mis là (indépendamment du fait que c'est
moi qui l'ai mis et avec quelle version du fichier). En plus, comme
j'ai vu ça dans une copie, j'ai oublié après et je n'ai pas encore
mis les commentaires appropriés. Je vais m'atteler à ça en arrivant
demain.
Sur les applications de traduction, j'ai tendance à avoir un peu de
flottement : soit je mets les noms en Anglais pour être bien compris
de tous ceux qui passent derrière, soit, si c'est une application que
je suis censé mener seul à terme pour une boîte française, je les
mets en Français pour défendre la culture. Moyennant quoi, il m'est
même arrivé de faire un panachage des deux dans une même application,
ce qui je crois est bien la seule solution non défendable.
j'aimais bien utiliser le &, c'était commode, et puis on m'a expliqué
que c'était une application qu'il allait falloir convertir sur
plusieurs versions d'Access, donc on la développait avec la version
la plus ancienne (II dans un cas, 95 dans un autre), et elle allait
ensuite tourner sur les autres versions. Dans ce cas de figure, si on
a un & qui se balade quelque part dans le code, on se fait jeter au
moment de la conversion.
En tout cas, merci beaucoup pour ces remarques. On devrait faire ça
plus souvent, on verrait moins d'horreurs quand on passe faire de la
maintenance de code.
Jean-marc a écrit, le 17/07/2007 22:11 :
Hello,
Que voilà pourtant des conseils précieux.
Le N était une réminiscence du GWbasic, comme quoi, quand on est
dynosaure, de nos jours, il faut s'adapter ...
Le coup du ByVal, il m'est arrivé la semaine dernière d'être obligé de
le mettre, sinon ça plantait juste à cause de ça. Sinon, c'est vrai
que j'ai un peu une fâcheuse tendance à négliger ça.
Je mets toujours vbCrLf plutôt que chr$(13) + chr$(10), mais le
vbNullChar je ne l'avais pas en tête. Je devrais me mettre à jour
là-dessus aussi. A ce que j'ai entendu c'est un motif de se faire
rétamer par la moulinette de conversion automatique de VB6 vers VB.Net
Ah, oui, le coup de stocker un calcul intermédiaire dans une variable
avant de s'en servir plusieurs fois, quelqu'un (peut-être toi) m'en
avait parlé il y a un an ou deux. ça va bien finir par entrer.
J'entendais bien une idée qui me rôdait dans la tête, aussi, quand
j'ai tapé ça :)
Ah, oui, l'indentation, jamais moyen de savoir à l'avance comment elle
sera faite ici. J'aurais bien guetté la parution pour voir comment ça
sortait, et puis je l'ai découverte en même temps que ta réponse.
C'est vrai que mettre une condition dans une variable booléenne ça
allège la syntaxe, mais alors il faut veiller à l'initialiser au bon
endroit. Souvent, une fois avant la boucle, et une fois à la fin
(surtout pour un While).
C'est vrai que les commentaires c'est un truc auquel on pense parfois
un peu tard. Ce matin, j'ai réalisé que je n'ai même pas écrit dans
mon module pourquoi je l'ai mis là (indépendamment du fait que c'est
moi qui l'ai mis et avec quelle version du fichier). En plus, comme
j'ai vu ça dans une copie, j'ai oublié après et je n'ai pas encore
mis les commentaires appropriés. Je vais m'atteler à ça en arrivant
demain.
Sur les applications de traduction, j'ai tendance à avoir un peu de
flottement : soit je mets les noms en Anglais pour être bien compris
de tous ceux qui passent derrière, soit, si c'est une application que
je suis censé mener seul à terme pour une boîte française, je les
mets en Français pour défendre la culture. Moyennant quoi, il m'est
même arrivé de faire un panachage des deux dans une même application,
ce qui je crois est bien la seule solution non défendable.
j'aimais bien utiliser le &, c'était commode, et puis on m'a expliqué
que c'était une application qu'il allait falloir convertir sur
plusieurs versions d'Access, donc on la développait avec la version
la plus ancienne (II dans un cas, 95 dans un autre), et elle allait
ensuite tourner sur les autres versions. Dans ce cas de figure, si on
a un & qui se balade quelque part dans le code, on se fait jeter au
moment de la conversion.
En tout cas, merci beaucoup pour ces remarques. On devrait faire ça
plus souvent, on verrait moins d'horreurs quand on passe faire de la
maintenance de code.
Jean-marc a écrit, le 17/07/2007 22:11 :Hello,
Que voilà pourtant des conseils précieux.
Le N était une réminiscence du GWbasic, comme quoi, quand on est
dynosaure, de nos jours, il faut s'adapter ...
Le coup du ByVal, il m'est arrivé la semaine dernière d'être obligé de
le mettre, sinon ça plantait juste à cause de ça. Sinon, c'est vrai
que j'ai un peu une fâcheuse tendance à négliger ça.
Je mets toujours vbCrLf plutôt que chr$(13) + chr$(10), mais le
vbNullChar je ne l'avais pas en tête. Je devrais me mettre à jour
là-dessus aussi. A ce que j'ai entendu c'est un motif de se faire
rétamer par la moulinette de conversion automatique de VB6 vers VB.Net
Ah, oui, le coup de stocker un calcul intermédiaire dans une variable
avant de s'en servir plusieurs fois, quelqu'un (peut-être toi) m'en
avait parlé il y a un an ou deux. ça va bien finir par entrer.
J'entendais bien une idée qui me rôdait dans la tête, aussi, quand
j'ai tapé ça :)
Ah, oui, l'indentation, jamais moyen de savoir à l'avance comment elle
sera faite ici. J'aurais bien guetté la parution pour voir comment ça
sortait, et puis je l'ai découverte en même temps que ta réponse.
C'est vrai que mettre une condition dans une variable booléenne ça
allège la syntaxe, mais alors il faut veiller à l'initialiser au bon
endroit. Souvent, une fois avant la boucle, et une fois à la fin
(surtout pour un While).
C'est vrai que les commentaires c'est un truc auquel on pense parfois
un peu tard. Ce matin, j'ai réalisé que je n'ai même pas écrit dans
mon module pourquoi je l'ai mis là (indépendamment du fait que c'est
moi qui l'ai mis et avec quelle version du fichier). En plus, comme
j'ai vu ça dans une copie, j'ai oublié après et je n'ai pas encore
mis les commentaires appropriés. Je vais m'atteler à ça en arrivant
demain.
Sur les applications de traduction, j'ai tendance à avoir un peu de
flottement : soit je mets les noms en Anglais pour être bien compris
de tous ceux qui passent derrière, soit, si c'est une application que
je suis censé mener seul à terme pour une boîte française, je les
mets en Français pour défendre la culture. Moyennant quoi, il m'est
même arrivé de faire un panachage des deux dans une même application,
ce qui je crois est bien la seule solution non défendable.
j'aimais bien utiliser le &, c'était commode, et puis on m'a expliqué
que c'était une application qu'il allait falloir convertir sur
plusieurs versions d'Access, donc on la développait avec la version
la plus ancienne (II dans un cas, 95 dans un autre), et elle allait
ensuite tourner sur les autres versions. Dans ce cas de figure, si on
a un & qui se balade quelque part dans le code, on se fait jeter au
moment de la conversion.
En tout cas, merci beaucoup pour ces remarques. On devrait faire ça
plus souvent, on verrait moins d'horreurs quand on passe faire de la
maintenance de code.