Rappel: Get est une instruction qui sert à écrire les données d'un fichier de données dans une variable.
Syntaxe: Get [#]filenumber, [recnumber], varname

En écrivant un fichier on se pose souvent la question, quelle est la meilleure façon de la lire.
La réponse est dans la méthode d'écriture.
Une fois que vous écrivez dans un fichier ouvert en mode binaire, à l'aide de l'instruction Put, il faut avoir à l'esprit le type de variable utilisé devant servir à lire celui-ci.
L'exemple suivant aide à mieux comprendre la manipulation de lecture.
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
 
Sub lecture_Binaire()
    Dim f As Integer, curLen As Integer, n1 As Long, n2 As Integer, n3 As Byte, n4 As Single, n5 As Double, _
        tL() As Long, tI() As Integer, tB() As Byte, tS() As Single, tD() As Double, tx(), tz() As Long, fic As String
 
    fic = "lire" 
 
 
    ReDim tL(1 To 5)
    ReDim tI(1 To 5)
    ReDim tB(1 To 5)
    ReDim tS(1 To 5)
    ReDim tD(1 To 5)
    ReDim tx(1 To 5, 1 To 1) 'longueur
    ReDim tz(1 To 5, 1 To 1)
 
    Open fic For Binary As #1
        'remplir le fichier avec une série de 20 nombres
        For f = 1 To 25
 
            n1 = n1 + 1: n2 = n2 + 1: n3 = n3 + 1: n4 = n4 + 1: n5 = n5 + 1
 
            Select Case f
                Case Is < 6
                    Put #1, , n1 'long
                Case 6 To 10
                    Put #1, , n2 'integer
                Case 11 To 15
                    Put #1, , n3 'byte
                Case 16 To 20
                    Put #1, , n4 'single
                Case Else
                    Put #1, , n5 'double
            End Select
        Next
 
        'lire chaque groupe d'octects correspondant au type de variables
        curLen = 1
        Get #1, 1, tL
        curLen = curLen + Len(tL(1)) * 5 'la nouvelle position de lecture en octect
        Get #1, curLen, tI
        curLen = curLen + (Len(tI(1)) * 5)
        Get #1, curLen, tB
        curLen = curLen + (Len(tB(1)) * 5)
        Get #1, curLen, tS
        curLen = curLen + (Len(tS(1)) * 5)
        Get #1, curLen, tD
        'afficher
        Debug.Print tL(1)
        Debug.Print tI(1)
        Debug.Print tB(1)
        Debug.Print tS(1)
        Debug.Print tD(1)
        'maintenant lecture de plage d'octets du Type Long dans un type non correspondant
        Get #1, 1, tD
        Debug.Print tD(1)
        'illustration du comportement de l'instruction Get qui lit la longueur du VarType tD(1). Soit 8 octets.
        'La valeur obtenue n'a rien à voir avec ce qu'on croit trouver.
        'En réalité deux valeurs: tL(1) et tL(2)ont été écrites dans tD(1)
        'Mais ce n'est pas tout! Vérifiez la position courante du curseur avec Seek
        curLen = Seek(1)
        'renvoi 41. Si vous suivez, vous comprendrez que tout le tableau tD() a été affecté, et que l'argument recNumber (pour positionner le curseur) dans l'objectif du contexte de lecture vers nos tableaux ne sert à rien si on accède dans l'ordre avec les variables correspondantes.
        'la longueur lue est équivalente à la longueur du tableau. 8*5 octets de données.
        'la tableau tD contient donc les variables écrites pour tL et Ti regroupés en 5 éléments.
        Get #1, 1, tx(1, 1)
        'les éléments de tx un tableau variant n'étant pas initialiés, Get tx(1,1) renverra NULL, le reste VIDE: Void
        'Initialisons
        For f = 1 To 5
            tx(f, 1) = 0
        Next
 
        'Get #1, 1, tx(1, 1) 'idem
 
        Get #1, 1, tx
        'pour le tableau Long bidimensionnel à une colonne
        Get #1, 1, tz(1, 1) 'incorrect
        Get #1, 1, tz ' remplissage correct
    Close #1
    'f = (8 ^ 4) / (2 ^ 9) = ((8 * 256 * 2) / 512)
 
    'pour dimensionner par exemple un tableau pour une lecture de groupe d'octets en fonction de la taille du fichier
    'on suppose que notre fichier contient 10 millions  huit cents mille octets de données et souhaitons le lire par groupe
    'de deux cents mille dans une boucle.
    'x = LOF(fic) / 200.000 ' qui nous donne 54 tours de boucle qui sera incrémenté au pas de 200.000 avec une variable de lecture initialisé à 200.000 octets.
 
End Sub
Voilà après lecture et essai de ce code on comprend un peu mieux le fonctionnement de Get. Il faut juste avoir sa méthode d'écriture organisé pour une lecture ciblée avec Get