Bonjour,
En VB 6, on peut lire, dans un fichier ouvert en binaire (1), une
chaîne S comprenant des Chr(0) par Input(1, S).
En VB 2005, les caractères 'Null' sont supprimés.
J'ai donc dû écrire une routine lisant caractère par caractère avec
FileGet() et remplaçant les résultats nuls par Chr(0) dans S.
Bonjour,
En VB 6, on peut lire, dans un fichier ouvert en binaire (1), une
chaîne S comprenant des Chr(0) par Input(1, S).
En VB 2005, les caractères 'Null' sont supprimés.
J'ai donc dû écrire une routine lisant caractère par caractère avec
FileGet() et remplaçant les résultats nuls par Chr(0) dans S.
Bonjour,
En VB 6, on peut lire, dans un fichier ouvert en binaire (1), une
chaîne S comprenant des Chr(0) par Input(1, S).
En VB 2005, les caractères 'Null' sont supprimés.
J'ai donc dû écrire une routine lisant caractère par caractère avec
FileGet() et remplaçant les résultats nuls par Chr(0) dans S.
Hi Fred,
En folâtrant sur son clavier, Fred s'est exprimé ainsi :Dans son message
Aski nous dit :Bonjour,
Bonjour,En VB 6, on peut lire, dans un fichier ouvert en binaire (1), une
chaîne S comprenant des Chr(0) par Input(1, S).
En VB 2005, les caractères 'Null' sont supprimés.
J'ai donc dû écrire une routine lisant caractère par caractère avec
FileGet() et remplaçant les résultats nuls par Chr(0) dans S.
Tu me surprends là. Tu pourrais nous montrer un bout de code ?
Voici l'extrait en espérant être clair :
//////////////////////////////////////////////
'extrait de la fonction
Const SignatureOE5DbxFin As String > "66E3D1119A4E00C04FA309D40500000005000000"
Inp = FreeFile
FileOpen(Inp, DbxFileName, OpenMode.Binary)
Seek(Inp, &H8S + 1)
'fonction supprimant tous les caractères 'Null' et entraînant 'Exit
Function'
'Zone = InputString(Inp, 20)
'nouvelle fonction supprimant la sortie précédente
Zone = InputS(20)
ZoneHexa = Hexa(Zone)
If ZoneHexa <> SignatureOE5DbxFin Then NotValidFile() : Exit
Function 'fin de l'extrait
Private Function InputS(ByVal L As Long) As String
Dim i As Short
Dim S As Char
Dim Zone As String
Zone = ""
For i = 1 To L
FileGet(Inp, S)
If S = "" Then S = Chr(0)
Zone = Zone & S
Next i
InputS = Zone
End Function
Private Function Hexa(ByRef S As String) As String
Dim ValAscii As Short
Dim i As Integer
Dim R As String
R = ""
For i = 1 To Len(S)
ValAscii = Asc(Mid(S, i, 1))
R = R & Hex(Int(ValAscii / 16)) & Hex(ValAscii Mod 16)
Next i
Hexa = R
End Function
//////////////////////////////////////////////Je ne suis (pour l'instant ;-) qu'en vb 2003 mais de toute façon
cela dépend du framework. Quand tu ouvres un fichier en binaire, je
ne pense pas qu'il interfère en quoi que ce soit. Peut-être
devrais-tu voir les nouvelles méthodes et ne plus utiliser les Chr,
Input et autres fonctions du VB6.
Voilà un petit bout de code issue de la MSDN
8<--------
fs = New FileStream(FILE_NAME, FileMode.Open, FileAccess.Read)
Dim r As New BinaryReader(fs)
For i = 0 To 10
Console.WriteLine(r.ReadInt32())
Next i
8<----------
Vois donc du côté de BinaryReader et plus particulièrement la
méthode ReadBytes qui te renvoie un tableau d'octets.
Ensuite, et c'est là qu'on trouve de grandes différences par rapport
à VB6, tu vas 'interpréter' ton tableau d'octets en fonction d'un
encodage pour obtenir une chaîne de caractères. Par exemple :
8<----------
Dim encoding As System.Text.Encoding = System.Text.Encoding.UTF8
Dim s As String = encoding.GetString(buffer)
8<----------
Regarde donc du côté de la classe System.Text.Encoding pour plus de
détails.
Voilà de très bons conseils qui seront durs à digérer. :-(
Je pensais que Visual Basic 2005 serait proche de VB 6. Il n'en est
rien. Je retrouve quelques éléments du C, du Pascal ...
Il faut savoit évoluer. ;-)
En tous cas, merci de ton aide.
Henri
Hi Fred,
En folâtrant sur son clavier, Fred s'est exprimé ainsi :
Dans son message OHi0cbPYFHA.584@TK2MSFTNGP15.phx.gbl
Aski nous dit :
Bonjour,
Bonjour,
En VB 6, on peut lire, dans un fichier ouvert en binaire (1), une
chaîne S comprenant des Chr(0) par Input(1, S).
En VB 2005, les caractères 'Null' sont supprimés.
J'ai donc dû écrire une routine lisant caractère par caractère avec
FileGet() et remplaçant les résultats nuls par Chr(0) dans S.
Tu me surprends là. Tu pourrais nous montrer un bout de code ?
Voici l'extrait en espérant être clair :
//////////////////////////////////////////////
'extrait de la fonction
Const SignatureOE5DbxFin As String > "66E3D1119A4E00C04FA309D40500000005000000"
Inp = FreeFile
FileOpen(Inp, DbxFileName, OpenMode.Binary)
Seek(Inp, &H8S + 1)
'fonction supprimant tous les caractères 'Null' et entraînant 'Exit
Function'
'Zone = InputString(Inp, 20)
'nouvelle fonction supprimant la sortie précédente
Zone = InputS(20)
ZoneHexa = Hexa(Zone)
If ZoneHexa <> SignatureOE5DbxFin Then NotValidFile() : Exit
Function 'fin de l'extrait
Private Function InputS(ByVal L As Long) As String
Dim i As Short
Dim S As Char
Dim Zone As String
Zone = ""
For i = 1 To L
FileGet(Inp, S)
If S = "" Then S = Chr(0)
Zone = Zone & S
Next i
InputS = Zone
End Function
Private Function Hexa(ByRef S As String) As String
Dim ValAscii As Short
Dim i As Integer
Dim R As String
R = ""
For i = 1 To Len(S)
ValAscii = Asc(Mid(S, i, 1))
R = R & Hex(Int(ValAscii / 16)) & Hex(ValAscii Mod 16)
Next i
Hexa = R
End Function
//////////////////////////////////////////////
Je ne suis (pour l'instant ;-) qu'en vb 2003 mais de toute façon
cela dépend du framework. Quand tu ouvres un fichier en binaire, je
ne pense pas qu'il interfère en quoi que ce soit. Peut-être
devrais-tu voir les nouvelles méthodes et ne plus utiliser les Chr,
Input et autres fonctions du VB6.
Voilà un petit bout de code issue de la MSDN
8<--------
fs = New FileStream(FILE_NAME, FileMode.Open, FileAccess.Read)
Dim r As New BinaryReader(fs)
For i = 0 To 10
Console.WriteLine(r.ReadInt32())
Next i
8<----------
Vois donc du côté de BinaryReader et plus particulièrement la
méthode ReadBytes qui te renvoie un tableau d'octets.
Ensuite, et c'est là qu'on trouve de grandes différences par rapport
à VB6, tu vas 'interpréter' ton tableau d'octets en fonction d'un
encodage pour obtenir une chaîne de caractères. Par exemple :
8<----------
Dim encoding As System.Text.Encoding = System.Text.Encoding.UTF8
Dim s As String = encoding.GetString(buffer)
8<----------
Regarde donc du côté de la classe System.Text.Encoding pour plus de
détails.
Voilà de très bons conseils qui seront durs à digérer. :-(
Je pensais que Visual Basic 2005 serait proche de VB 6. Il n'en est
rien. Je retrouve quelques éléments du C, du Pascal ...
Il faut savoit évoluer. ;-)
En tous cas, merci de ton aide.
Henri
Hi Fred,
En folâtrant sur son clavier, Fred s'est exprimé ainsi :Dans son message
Aski nous dit :Bonjour,
Bonjour,En VB 6, on peut lire, dans un fichier ouvert en binaire (1), une
chaîne S comprenant des Chr(0) par Input(1, S).
En VB 2005, les caractères 'Null' sont supprimés.
J'ai donc dû écrire une routine lisant caractère par caractère avec
FileGet() et remplaçant les résultats nuls par Chr(0) dans S.
Tu me surprends là. Tu pourrais nous montrer un bout de code ?
Voici l'extrait en espérant être clair :
//////////////////////////////////////////////
'extrait de la fonction
Const SignatureOE5DbxFin As String > "66E3D1119A4E00C04FA309D40500000005000000"
Inp = FreeFile
FileOpen(Inp, DbxFileName, OpenMode.Binary)
Seek(Inp, &H8S + 1)
'fonction supprimant tous les caractères 'Null' et entraînant 'Exit
Function'
'Zone = InputString(Inp, 20)
'nouvelle fonction supprimant la sortie précédente
Zone = InputS(20)
ZoneHexa = Hexa(Zone)
If ZoneHexa <> SignatureOE5DbxFin Then NotValidFile() : Exit
Function 'fin de l'extrait
Private Function InputS(ByVal L As Long) As String
Dim i As Short
Dim S As Char
Dim Zone As String
Zone = ""
For i = 1 To L
FileGet(Inp, S)
If S = "" Then S = Chr(0)
Zone = Zone & S
Next i
InputS = Zone
End Function
Private Function Hexa(ByRef S As String) As String
Dim ValAscii As Short
Dim i As Integer
Dim R As String
R = ""
For i = 1 To Len(S)
ValAscii = Asc(Mid(S, i, 1))
R = R & Hex(Int(ValAscii / 16)) & Hex(ValAscii Mod 16)
Next i
Hexa = R
End Function
//////////////////////////////////////////////Je ne suis (pour l'instant ;-) qu'en vb 2003 mais de toute façon
cela dépend du framework. Quand tu ouvres un fichier en binaire, je
ne pense pas qu'il interfère en quoi que ce soit. Peut-être
devrais-tu voir les nouvelles méthodes et ne plus utiliser les Chr,
Input et autres fonctions du VB6.
Voilà un petit bout de code issue de la MSDN
8<--------
fs = New FileStream(FILE_NAME, FileMode.Open, FileAccess.Read)
Dim r As New BinaryReader(fs)
For i = 0 To 10
Console.WriteLine(r.ReadInt32())
Next i
8<----------
Vois donc du côté de BinaryReader et plus particulièrement la
méthode ReadBytes qui te renvoie un tableau d'octets.
Ensuite, et c'est là qu'on trouve de grandes différences par rapport
à VB6, tu vas 'interpréter' ton tableau d'octets en fonction d'un
encodage pour obtenir une chaîne de caractères. Par exemple :
8<----------
Dim encoding As System.Text.Encoding = System.Text.Encoding.UTF8
Dim s As String = encoding.GetString(buffer)
8<----------
Regarde donc du côté de la classe System.Text.Encoding pour plus de
détails.
Voilà de très bons conseils qui seront durs à digérer. :-(
Je pensais que Visual Basic 2005 serait proche de VB 6. Il n'en est
rien. Je retrouve quelques éléments du C, du Pascal ...
Il faut savoit évoluer. ;-)
En tous cas, merci de ton aide.
Henri
Hi,
En folâtrant sur son clavier, Fred s'est exprimé ainsi :Dans son message
Aski nous dit :Hi Fred,
En folâtrant sur son clavier, Fred s'est exprimé ainsi :Dans son message
Aski nous dit :Bonjour,
Bonjour,En VB 6, on peut lire, dans un fichier ouvert en binaire (1),
une chaîne S comprenant des Chr(0) par Input(1, S).
En VB 2005, les caractères 'Null' sont supprimés.
J'ai donc dû écrire une routine lisant caractère par caractère
avec FileGet() et remplaçant les résultats nuls par Chr(0) dans
S.
Tu me surprends là. Tu pourrais nous montrer un bout de code ?
Voici l'extrait en espérant être clair :
//////////////////////////////////////////////
'extrait de la fonction
Const SignatureOE5DbxFin As String >>>> "66E3D1119A4E00C04FA309D40500000005000000"
Inp = FreeFile
FileOpen(Inp, DbxFileName, OpenMode.Binary)
Seek(Inp, &H8S + 1)
'fonction supprimant tous les caractères 'Null' et entraînant
'Exit Function'
'Zone = InputString(Inp, 20)
'nouvelle fonction supprimant la sortie précédente
Zone = InputS(20)
ZoneHexa = Hexa(Zone)
If ZoneHexa <> SignatureOE5DbxFin Then NotValidFile() : Exit
Function 'fin de l'extrait
Private Function InputS(ByVal L As Long) As String
Dim i As Short
Dim S As Char
Dim Zone As String
Zone = ""
For i = 1 To L
FileGet(Inp, S)
If S = "" Then S = Chr(0)
Zone = Zone & S
Next i
InputS = Zone
End Function
Private Function Hexa(ByRef S As String) As String
Dim ValAscii As Short
Dim i As Integer
Dim R As String
R = ""
For i = 1 To Len(S)
ValAscii = Asc(Mid(S, i, 1))
R = R & Hex(Int(ValAscii / 16)) & Hex(ValAscii Mod 16)
Next i
Hexa = R
End Function
//////////////////////////////////////////////Je ne suis (pour l'instant ;-) qu'en vb 2003 mais de toute façon
cela dépend du framework. Quand tu ouvres un fichier en binaire,
je ne pense pas qu'il interfère en quoi que ce soit. Peut-être
devrais-tu voir les nouvelles méthodes et ne plus utiliser les
Chr, Input et autres fonctions du VB6.
Voilà un petit bout de code issue de la MSDN
8<--------
fs = New FileStream(FILE_NAME, FileMode.Open, FileAccess.Read)
Dim r As New BinaryReader(fs)
For i = 0 To 10
Console.WriteLine(r.ReadInt32())
Next i
8<----------
Vois donc du côté de BinaryReader et plus particulièrement la
méthode ReadBytes qui te renvoie un tableau d'octets.
Ensuite, et c'est là qu'on trouve de grandes différences par
rapport à VB6, tu vas 'interpréter' ton tableau d'octets en
fonction d'un encodage pour obtenir une chaîne de caractères. Par
exemple :
8<----------
Dim encoding As System.Text.Encoding = System.Text.Encoding.UTF8
Dim s As String = encoding.GetString(buffer)
8<----------
Regarde donc du côté de la classe System.Text.Encoding pour plus
de détails.
Voilà de très bons conseils qui seront durs à digérer. :-(
Je pensais que Visual Basic 2005 serait proche de VB 6. Il n'en est
rien. Je retrouve quelques éléments du C, du Pascal ...
Il faut savoit évoluer. ;-)
En tous cas, merci de ton aide.
Henri
Bonjour Henri,
En fait (et je m'en doutais un peu), tu ne cherches pas à lire une
chaîne mais bien une succession d'octets.
Donc pas besoin du System.Text ici.
Il faut juste comparer le tableau d'octets lus avec un tableau de
référence. Je n'ai pas testé ce que fait le GetString des octets
nuls en encodage ASCII.
PS : regarde aussi tout ce que peut faire la classe System.Convert !
Impressionnant.
Merci. Je pense effectivement utiliser des tableaux de bytes.
Tout ceci ressemble de plus en plus au C.
Henri
Hi,
En folâtrant sur son clavier, Fred s'est exprimé ainsi :
Dans son message OUppWJSYFHA.3320@TK2MSFTNGP12.phx.gbl
Aski nous dit :
Hi Fred,
En folâtrant sur son clavier, Fred s'est exprimé ainsi :
Dans son message OHi0cbPYFHA.584@TK2MSFTNGP15.phx.gbl
Aski nous dit :
Bonjour,
Bonjour,
En VB 6, on peut lire, dans un fichier ouvert en binaire (1),
une chaîne S comprenant des Chr(0) par Input(1, S).
En VB 2005, les caractères 'Null' sont supprimés.
J'ai donc dû écrire une routine lisant caractère par caractère
avec FileGet() et remplaçant les résultats nuls par Chr(0) dans
S.
Tu me surprends là. Tu pourrais nous montrer un bout de code ?
Voici l'extrait en espérant être clair :
//////////////////////////////////////////////
'extrait de la fonction
Const SignatureOE5DbxFin As String >>>> "66E3D1119A4E00C04FA309D40500000005000000"
Inp = FreeFile
FileOpen(Inp, DbxFileName, OpenMode.Binary)
Seek(Inp, &H8S + 1)
'fonction supprimant tous les caractères 'Null' et entraînant
'Exit Function'
'Zone = InputString(Inp, 20)
'nouvelle fonction supprimant la sortie précédente
Zone = InputS(20)
ZoneHexa = Hexa(Zone)
If ZoneHexa <> SignatureOE5DbxFin Then NotValidFile() : Exit
Function 'fin de l'extrait
Private Function InputS(ByVal L As Long) As String
Dim i As Short
Dim S As Char
Dim Zone As String
Zone = ""
For i = 1 To L
FileGet(Inp, S)
If S = "" Then S = Chr(0)
Zone = Zone & S
Next i
InputS = Zone
End Function
Private Function Hexa(ByRef S As String) As String
Dim ValAscii As Short
Dim i As Integer
Dim R As String
R = ""
For i = 1 To Len(S)
ValAscii = Asc(Mid(S, i, 1))
R = R & Hex(Int(ValAscii / 16)) & Hex(ValAscii Mod 16)
Next i
Hexa = R
End Function
//////////////////////////////////////////////
Je ne suis (pour l'instant ;-) qu'en vb 2003 mais de toute façon
cela dépend du framework. Quand tu ouvres un fichier en binaire,
je ne pense pas qu'il interfère en quoi que ce soit. Peut-être
devrais-tu voir les nouvelles méthodes et ne plus utiliser les
Chr, Input et autres fonctions du VB6.
Voilà un petit bout de code issue de la MSDN
8<--------
fs = New FileStream(FILE_NAME, FileMode.Open, FileAccess.Read)
Dim r As New BinaryReader(fs)
For i = 0 To 10
Console.WriteLine(r.ReadInt32())
Next i
8<----------
Vois donc du côté de BinaryReader et plus particulièrement la
méthode ReadBytes qui te renvoie un tableau d'octets.
Ensuite, et c'est là qu'on trouve de grandes différences par
rapport à VB6, tu vas 'interpréter' ton tableau d'octets en
fonction d'un encodage pour obtenir une chaîne de caractères. Par
exemple :
8<----------
Dim encoding As System.Text.Encoding = System.Text.Encoding.UTF8
Dim s As String = encoding.GetString(buffer)
8<----------
Regarde donc du côté de la classe System.Text.Encoding pour plus
de détails.
Voilà de très bons conseils qui seront durs à digérer. :-(
Je pensais que Visual Basic 2005 serait proche de VB 6. Il n'en est
rien. Je retrouve quelques éléments du C, du Pascal ...
Il faut savoit évoluer. ;-)
En tous cas, merci de ton aide.
Henri
Bonjour Henri,
En fait (et je m'en doutais un peu), tu ne cherches pas à lire une
chaîne mais bien une succession d'octets.
Donc pas besoin du System.Text ici.
Il faut juste comparer le tableau d'octets lus avec un tableau de
référence. Je n'ai pas testé ce que fait le GetString des octets
nuls en encodage ASCII.
PS : regarde aussi tout ce que peut faire la classe System.Convert !
Impressionnant.
Merci. Je pense effectivement utiliser des tableaux de bytes.
Tout ceci ressemble de plus en plus au C.
Henri
Hi,
En folâtrant sur son clavier, Fred s'est exprimé ainsi :Dans son message
Aski nous dit :Hi Fred,
En folâtrant sur son clavier, Fred s'est exprimé ainsi :Dans son message
Aski nous dit :Bonjour,
Bonjour,En VB 6, on peut lire, dans un fichier ouvert en binaire (1),
une chaîne S comprenant des Chr(0) par Input(1, S).
En VB 2005, les caractères 'Null' sont supprimés.
J'ai donc dû écrire une routine lisant caractère par caractère
avec FileGet() et remplaçant les résultats nuls par Chr(0) dans
S.
Tu me surprends là. Tu pourrais nous montrer un bout de code ?
Voici l'extrait en espérant être clair :
//////////////////////////////////////////////
'extrait de la fonction
Const SignatureOE5DbxFin As String >>>> "66E3D1119A4E00C04FA309D40500000005000000"
Inp = FreeFile
FileOpen(Inp, DbxFileName, OpenMode.Binary)
Seek(Inp, &H8S + 1)
'fonction supprimant tous les caractères 'Null' et entraînant
'Exit Function'
'Zone = InputString(Inp, 20)
'nouvelle fonction supprimant la sortie précédente
Zone = InputS(20)
ZoneHexa = Hexa(Zone)
If ZoneHexa <> SignatureOE5DbxFin Then NotValidFile() : Exit
Function 'fin de l'extrait
Private Function InputS(ByVal L As Long) As String
Dim i As Short
Dim S As Char
Dim Zone As String
Zone = ""
For i = 1 To L
FileGet(Inp, S)
If S = "" Then S = Chr(0)
Zone = Zone & S
Next i
InputS = Zone
End Function
Private Function Hexa(ByRef S As String) As String
Dim ValAscii As Short
Dim i As Integer
Dim R As String
R = ""
For i = 1 To Len(S)
ValAscii = Asc(Mid(S, i, 1))
R = R & Hex(Int(ValAscii / 16)) & Hex(ValAscii Mod 16)
Next i
Hexa = R
End Function
//////////////////////////////////////////////Je ne suis (pour l'instant ;-) qu'en vb 2003 mais de toute façon
cela dépend du framework. Quand tu ouvres un fichier en binaire,
je ne pense pas qu'il interfère en quoi que ce soit. Peut-être
devrais-tu voir les nouvelles méthodes et ne plus utiliser les
Chr, Input et autres fonctions du VB6.
Voilà un petit bout de code issue de la MSDN
8<--------
fs = New FileStream(FILE_NAME, FileMode.Open, FileAccess.Read)
Dim r As New BinaryReader(fs)
For i = 0 To 10
Console.WriteLine(r.ReadInt32())
Next i
8<----------
Vois donc du côté de BinaryReader et plus particulièrement la
méthode ReadBytes qui te renvoie un tableau d'octets.
Ensuite, et c'est là qu'on trouve de grandes différences par
rapport à VB6, tu vas 'interpréter' ton tableau d'octets en
fonction d'un encodage pour obtenir une chaîne de caractères. Par
exemple :
8<----------
Dim encoding As System.Text.Encoding = System.Text.Encoding.UTF8
Dim s As String = encoding.GetString(buffer)
8<----------
Regarde donc du côté de la classe System.Text.Encoding pour plus
de détails.
Voilà de très bons conseils qui seront durs à digérer. :-(
Je pensais que Visual Basic 2005 serait proche de VB 6. Il n'en est
rien. Je retrouve quelques éléments du C, du Pascal ...
Il faut savoit évoluer. ;-)
En tous cas, merci de ton aide.
Henri
Bonjour Henri,
En fait (et je m'en doutais un peu), tu ne cherches pas à lire une
chaîne mais bien une succession d'octets.
Donc pas besoin du System.Text ici.
Il faut juste comparer le tableau d'octets lus avec un tableau de
référence. Je n'ai pas testé ce que fait le GetString des octets
nuls en encodage ASCII.
PS : regarde aussi tout ce que peut faire la classe System.Convert !
Impressionnant.
Merci. Je pense effectivement utiliser des tableaux de bytes.
Tout ceci ressemble de plus en plus au C.
Henri
Dans son message
Aski nous dit :Hi,
En folâtrant sur son clavier, Fred s'est exprimé ainsi :Dans son message
Aski nous dit :Hi Fred,
En folâtrant sur son clavier, Fred s'est exprimé ainsi :Dans son message
Aski nous dit :Bonjour,
Bonjour,En VB 6, on peut lire, dans un fichier ouvert en binaire (1),
une chaîne S comprenant des Chr(0) par Input(1, S).
En VB 2005, les caractères 'Null' sont supprimés.
J'ai donc dû écrire une routine lisant caractère par caractère
avec FileGet() et remplaçant les résultats nuls par Chr(0) dans
S.
Tu me surprends là. Tu pourrais nous montrer un bout de code ?
Voici l'extrait en espérant être clair :
//////////////////////////////////////////////
'extrait de la fonction
Const SignatureOE5DbxFin As String >>>>> "66E3D1119A4E00C04FA309D40500000005000000"
Inp = FreeFile
FileOpen(Inp, DbxFileName, OpenMode.Binary)
Seek(Inp, &H8S + 1)
'fonction supprimant tous les caractères 'Null' et entraînant
'Exit Function'
'Zone = InputString(Inp, 20)
'nouvelle fonction supprimant la sortie précédente
Zone = InputS(20)
ZoneHexa = Hexa(Zone)
If ZoneHexa <> SignatureOE5DbxFin Then NotValidFile() : Exit
Function 'fin de l'extrait
Private Function InputS(ByVal L As Long) As String
Dim i As Short
Dim S As Char
Dim Zone As String
Zone = ""
For i = 1 To L
FileGet(Inp, S)
If S = "" Then S = Chr(0)
Zone = Zone & S
Next i
InputS = Zone
End Function
Private Function Hexa(ByRef S As String) As String
Dim ValAscii As Short
Dim i As Integer
Dim R As String
R = ""
For i = 1 To Len(S)
ValAscii = Asc(Mid(S, i, 1))
R = R & Hex(Int(ValAscii / 16)) & Hex(ValAscii Mod 16)
Next i
Hexa = R
End Function
//////////////////////////////////////////////Je ne suis (pour l'instant ;-) qu'en vb 2003 mais de toute façon
cela dépend du framework. Quand tu ouvres un fichier en binaire,
je ne pense pas qu'il interfère en quoi que ce soit. Peut-être
devrais-tu voir les nouvelles méthodes et ne plus utiliser les
Chr, Input et autres fonctions du VB6.
Voilà un petit bout de code issue de la MSDN
8<--------
fs = New FileStream(FILE_NAME, FileMode.Open, FileAccess.Read)
Dim r As New BinaryReader(fs)
For i = 0 To 10
Console.WriteLine(r.ReadInt32())
Next i
8<----------
Vois donc du côté de BinaryReader et plus particulièrement la
méthode ReadBytes qui te renvoie un tableau d'octets.
Ensuite, et c'est là qu'on trouve de grandes différences par
rapport à VB6, tu vas 'interpréter' ton tableau d'octets en
fonction d'un encodage pour obtenir une chaîne de caractères. Par
exemple :
8<----------
Dim encoding As System.Text.Encoding = System.Text.Encoding.UTF8
Dim s As String = encoding.GetString(buffer)
8<----------
Regarde donc du côté de la classe System.Text.Encoding pour plus
de détails.
Voilà de très bons conseils qui seront durs à digérer. :-(
Je pensais que Visual Basic 2005 serait proche de VB 6. Il n'en est
rien. Je retrouve quelques éléments du C, du Pascal ...
Il faut savoit évoluer. ;-)
En tous cas, merci de ton aide.
Henri
Bonjour Henri,
En fait (et je m'en doutais un peu), tu ne cherches pas à lire une
chaîne mais bien une succession d'octets.
Donc pas besoin du System.Text ici.
Il faut juste comparer le tableau d'octets lus avec un tableau de
référence. Je n'ai pas testé ce que fait le GetString des octets
nuls en encodage ASCII.
PS : regarde aussi tout ce que peut faire la classe System.Convert !
Impressionnant.
Merci. Je pense effectivement utiliser des tableaux de bytes.
Tout ceci ressemble de plus en plus au C.
Henri
Mais non, mais non :-)
J'ai toujours trouvé que cette façon de traiter les octets, de Quick Basic
à VB6 n'était pas très naturelle.
Avec vb .NET, on a le choix.
Tu peux aussi te faire aider sur m.p.fr.dotnet.vb
Bonne soirée
--
Fred
Dans son message OUXAfdVYFHA.584@TK2MSFTNGP15.phx.gbl
Aski nous dit :
Hi,
En folâtrant sur son clavier, Fred s'est exprimé ainsi :
Dans son message OUppWJSYFHA.3320@TK2MSFTNGP12.phx.gbl
Aski nous dit :
Hi Fred,
En folâtrant sur son clavier, Fred s'est exprimé ainsi :
Dans son message OHi0cbPYFHA.584@TK2MSFTNGP15.phx.gbl
Aski nous dit :
Bonjour,
Bonjour,
En VB 6, on peut lire, dans un fichier ouvert en binaire (1),
une chaîne S comprenant des Chr(0) par Input(1, S).
En VB 2005, les caractères 'Null' sont supprimés.
J'ai donc dû écrire une routine lisant caractère par caractère
avec FileGet() et remplaçant les résultats nuls par Chr(0) dans
S.
Tu me surprends là. Tu pourrais nous montrer un bout de code ?
Voici l'extrait en espérant être clair :
//////////////////////////////////////////////
'extrait de la fonction
Const SignatureOE5DbxFin As String >>>>> "66E3D1119A4E00C04FA309D40500000005000000"
Inp = FreeFile
FileOpen(Inp, DbxFileName, OpenMode.Binary)
Seek(Inp, &H8S + 1)
'fonction supprimant tous les caractères 'Null' et entraînant
'Exit Function'
'Zone = InputString(Inp, 20)
'nouvelle fonction supprimant la sortie précédente
Zone = InputS(20)
ZoneHexa = Hexa(Zone)
If ZoneHexa <> SignatureOE5DbxFin Then NotValidFile() : Exit
Function 'fin de l'extrait
Private Function InputS(ByVal L As Long) As String
Dim i As Short
Dim S As Char
Dim Zone As String
Zone = ""
For i = 1 To L
FileGet(Inp, S)
If S = "" Then S = Chr(0)
Zone = Zone & S
Next i
InputS = Zone
End Function
Private Function Hexa(ByRef S As String) As String
Dim ValAscii As Short
Dim i As Integer
Dim R As String
R = ""
For i = 1 To Len(S)
ValAscii = Asc(Mid(S, i, 1))
R = R & Hex(Int(ValAscii / 16)) & Hex(ValAscii Mod 16)
Next i
Hexa = R
End Function
//////////////////////////////////////////////
Je ne suis (pour l'instant ;-) qu'en vb 2003 mais de toute façon
cela dépend du framework. Quand tu ouvres un fichier en binaire,
je ne pense pas qu'il interfère en quoi que ce soit. Peut-être
devrais-tu voir les nouvelles méthodes et ne plus utiliser les
Chr, Input et autres fonctions du VB6.
Voilà un petit bout de code issue de la MSDN
8<--------
fs = New FileStream(FILE_NAME, FileMode.Open, FileAccess.Read)
Dim r As New BinaryReader(fs)
For i = 0 To 10
Console.WriteLine(r.ReadInt32())
Next i
8<----------
Vois donc du côté de BinaryReader et plus particulièrement la
méthode ReadBytes qui te renvoie un tableau d'octets.
Ensuite, et c'est là qu'on trouve de grandes différences par
rapport à VB6, tu vas 'interpréter' ton tableau d'octets en
fonction d'un encodage pour obtenir une chaîne de caractères. Par
exemple :
8<----------
Dim encoding As System.Text.Encoding = System.Text.Encoding.UTF8
Dim s As String = encoding.GetString(buffer)
8<----------
Regarde donc du côté de la classe System.Text.Encoding pour plus
de détails.
Voilà de très bons conseils qui seront durs à digérer. :-(
Je pensais que Visual Basic 2005 serait proche de VB 6. Il n'en est
rien. Je retrouve quelques éléments du C, du Pascal ...
Il faut savoit évoluer. ;-)
En tous cas, merci de ton aide.
Henri
Bonjour Henri,
En fait (et je m'en doutais un peu), tu ne cherches pas à lire une
chaîne mais bien une succession d'octets.
Donc pas besoin du System.Text ici.
Il faut juste comparer le tableau d'octets lus avec un tableau de
référence. Je n'ai pas testé ce que fait le GetString des octets
nuls en encodage ASCII.
PS : regarde aussi tout ce que peut faire la classe System.Convert !
Impressionnant.
Merci. Je pense effectivement utiliser des tableaux de bytes.
Tout ceci ressemble de plus en plus au C.
Henri
Mais non, mais non :-)
J'ai toujours trouvé que cette façon de traiter les octets, de Quick Basic
à VB6 n'était pas très naturelle.
Avec vb .NET, on a le choix.
Tu peux aussi te faire aider sur m.p.fr.dotnet.vb
Bonne soirée
--
Fred
Dans son message
Aski nous dit :Hi,
En folâtrant sur son clavier, Fred s'est exprimé ainsi :Dans son message
Aski nous dit :Hi Fred,
En folâtrant sur son clavier, Fred s'est exprimé ainsi :Dans son message
Aski nous dit :Bonjour,
Bonjour,En VB 6, on peut lire, dans un fichier ouvert en binaire (1),
une chaîne S comprenant des Chr(0) par Input(1, S).
En VB 2005, les caractères 'Null' sont supprimés.
J'ai donc dû écrire une routine lisant caractère par caractère
avec FileGet() et remplaçant les résultats nuls par Chr(0) dans
S.
Tu me surprends là. Tu pourrais nous montrer un bout de code ?
Voici l'extrait en espérant être clair :
//////////////////////////////////////////////
'extrait de la fonction
Const SignatureOE5DbxFin As String >>>>> "66E3D1119A4E00C04FA309D40500000005000000"
Inp = FreeFile
FileOpen(Inp, DbxFileName, OpenMode.Binary)
Seek(Inp, &H8S + 1)
'fonction supprimant tous les caractères 'Null' et entraînant
'Exit Function'
'Zone = InputString(Inp, 20)
'nouvelle fonction supprimant la sortie précédente
Zone = InputS(20)
ZoneHexa = Hexa(Zone)
If ZoneHexa <> SignatureOE5DbxFin Then NotValidFile() : Exit
Function 'fin de l'extrait
Private Function InputS(ByVal L As Long) As String
Dim i As Short
Dim S As Char
Dim Zone As String
Zone = ""
For i = 1 To L
FileGet(Inp, S)
If S = "" Then S = Chr(0)
Zone = Zone & S
Next i
InputS = Zone
End Function
Private Function Hexa(ByRef S As String) As String
Dim ValAscii As Short
Dim i As Integer
Dim R As String
R = ""
For i = 1 To Len(S)
ValAscii = Asc(Mid(S, i, 1))
R = R & Hex(Int(ValAscii / 16)) & Hex(ValAscii Mod 16)
Next i
Hexa = R
End Function
//////////////////////////////////////////////Je ne suis (pour l'instant ;-) qu'en vb 2003 mais de toute façon
cela dépend du framework. Quand tu ouvres un fichier en binaire,
je ne pense pas qu'il interfère en quoi que ce soit. Peut-être
devrais-tu voir les nouvelles méthodes et ne plus utiliser les
Chr, Input et autres fonctions du VB6.
Voilà un petit bout de code issue de la MSDN
8<--------
fs = New FileStream(FILE_NAME, FileMode.Open, FileAccess.Read)
Dim r As New BinaryReader(fs)
For i = 0 To 10
Console.WriteLine(r.ReadInt32())
Next i
8<----------
Vois donc du côté de BinaryReader et plus particulièrement la
méthode ReadBytes qui te renvoie un tableau d'octets.
Ensuite, et c'est là qu'on trouve de grandes différences par
rapport à VB6, tu vas 'interpréter' ton tableau d'octets en
fonction d'un encodage pour obtenir une chaîne de caractères. Par
exemple :
8<----------
Dim encoding As System.Text.Encoding = System.Text.Encoding.UTF8
Dim s As String = encoding.GetString(buffer)
8<----------
Regarde donc du côté de la classe System.Text.Encoding pour plus
de détails.
Voilà de très bons conseils qui seront durs à digérer. :-(
Je pensais que Visual Basic 2005 serait proche de VB 6. Il n'en est
rien. Je retrouve quelques éléments du C, du Pascal ...
Il faut savoit évoluer. ;-)
En tous cas, merci de ton aide.
Henri
Bonjour Henri,
En fait (et je m'en doutais un peu), tu ne cherches pas à lire une
chaîne mais bien une succession d'octets.
Donc pas besoin du System.Text ici.
Il faut juste comparer le tableau d'octets lus avec un tableau de
référence. Je n'ai pas testé ce que fait le GetString des octets
nuls en encodage ASCII.
PS : regarde aussi tout ce que peut faire la classe System.Convert !
Impressionnant.
Merci. Je pense effectivement utiliser des tableaux de bytes.
Tout ceci ressemble de plus en plus au C.
Henri
Mais non, mais non :-)
J'ai toujours trouvé que cette façon de traiter les octets, de Quick Basic
à VB6 n'était pas très naturelle.
Avec vb .NET, on a le choix.
Tu peux aussi te faire aider sur m.p.fr.dotnet.vb
Bonne soirée
--
Fred
Traiter des octets comme tableau de bytes ce n'est pas du C, puisqu'on
le faire directement en VB. De plus la lecture est plus rapide.
Chaque fois que c'est possible (c'est à dire chaque fois que les données
lues ne sont pas des chaînes de longueurs indéfinies), j'utilise une
random ou Binary.
Traiter des octets comme tableau de bytes ce n'est pas du C, puisqu'on
le faire directement en VB. De plus la lecture est plus rapide.
Chaque fois que c'est possible (c'est à dire chaque fois que les données
lues ne sont pas des chaînes de longueurs indéfinies), j'utilise une
random ou Binary.
Traiter des octets comme tableau de bytes ce n'est pas du C, puisqu'on
le faire directement en VB. De plus la lecture est plus rapide.
Chaque fois que c'est possible (c'est à dire chaque fois que les données
lues ne sont pas des chaînes de longueurs indéfinies), j'utilise une
random ou Binary.
