FileSystem.FilePut Méthode

Référence

Définition

Espace de noms:: Microsoft.VisualBasic

Assembly:: Microsoft.VisualBasic.Core.dll

Assembly:: Microsoft.VisualBasic.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Écrit les données d'une variable dans un fichier sur disque. La fonctionnalité My améliore la productivité et les performances des opérations d’E/S de fichier par rapport à FilePut. Pour plus d'informations, consultez FileSystem.

Surcharges

FilePut(Int32, Int64, Int64)	Écrit les données d'une variable dans un fichier sur disque. La fonctionnalité `My` améliore la productivité et les performances des opérations d’E/S de fichier par rapport à `FilePut`. Pour plus d'informations, consultez FileSystem.
FilePut(Int32, String, Int64, Boolean)	Écrit les données d'une variable dans un fichier sur disque. La fonctionnalité `My` améliore la productivité et les performances des opérations d’E/S de fichier par rapport à `FilePut`. Pour plus d'informations, consultez FileSystem.
FilePut(Object, Object, Object)	Obsolète. Obsolète. Obsolète. Écrit les données d'une variable dans un fichier sur disque. La fonctionnalité `My` améliore la productivité et les performances des opérations d’E/S de fichier par rapport à `FilePut`. Pour plus d'informations, consultez FileSystem.
FilePut(Int32, ValueType, Int64)	Écrit les données d'une variable dans un fichier sur disque. La fonctionnalité `My` améliore la productivité et les performances des opérations d’E/S de fichier par rapport à `FilePut`. Pour plus d'informations, consultez FileSystem.
FilePut(Int32, Single, Int64)	Écrit les données d'une variable dans un fichier sur disque. La fonctionnalité `My` améliore la productivité et les performances des opérations d’E/S de fichier par rapport à `FilePut`. Pour plus d'informations, consultez FileSystem.
FilePut(Int32, Int32, Int64)	Écrit les données d'une variable dans un fichier sur disque. La fonctionnalité `My` améliore la productivité et les performances des opérations d’E/S de fichier par rapport à `FilePut`. Pour plus d'informations, consultez FileSystem.
FilePut(Int32, Array, Int64, Boolean, Boolean)	Écrit les données d'une variable dans un fichier sur disque. La fonctionnalité `My` améliore la productivité et les performances des opérations d’E/S de fichier par rapport à `FilePut`. Pour plus d'informations, consultez FileSystem.
FilePut(Int32, Double, Int64)	Écrit les données d'une variable dans un fichier sur disque. La fonctionnalité `My` améliore la productivité et les performances des opérations d’E/S de fichier par rapport à `FilePut`. Pour plus d'informations, consultez FileSystem.
FilePut(Int32, Decimal, Int64)	Écrit les données d'une variable dans un fichier sur disque. La fonctionnalité `My` améliore la productivité et les performances des opérations d’E/S de fichier par rapport à `FilePut`. Pour plus d'informations, consultez FileSystem.
FilePut(Int32, DateTime, Int64)	Écrit les données d'une variable dans un fichier sur disque. La fonctionnalité `My` améliore la productivité et les performances des opérations d’E/S de fichier par rapport à `FilePut`. Pour plus d'informations, consultez FileSystem.
FilePut(Int32, Char, Int64)	Écrit les données d'une variable dans un fichier sur disque. La fonctionnalité `My` améliore la productivité et les performances des opérations d’E/S de fichier par rapport à `FilePut`. Pour plus d'informations, consultez FileSystem.
FilePut(Int32, Byte, Int64)	Écrit les données d'une variable dans un fichier sur disque. La fonctionnalité `My` améliore la productivité et les performances des opérations d’E/S de fichier par rapport à `FilePut`. Pour plus d'informations, consultez FileSystem.
FilePut(Int32, Boolean, Int64)	Écrit les données d'une variable dans un fichier sur disque. La fonctionnalité `My` améliore la productivité et les performances des opérations d’E/S de fichier par rapport à `FilePut`. Pour plus d'informations, consultez FileSystem.
FilePut(Int32, Int16, Int64)	Écrit les données d'une variable dans un fichier sur disque. La fonctionnalité `My` améliore la productivité et les performances des opérations d’E/S de fichier par rapport à `FilePut`. Pour plus d'informations, consultez FileSystem.

FilePut(Int32, Int64, Int64)

Source:: FileSystem.vb

Source:: FileSystem.vb

Source:: FileSystem.vb

public static void FilePut (int FileNumber, long Value, long RecordNumber = -1);

static member FilePut : int * int64 * int64 -> unit

Public Sub FilePut (FileNumber As Integer, Value As Long, Optional RecordNumber As Long = -1)

Paramètres

FileNumber: Int32

Obligatoire. N’importe quel numéro de fichier valide.

Value: Int64

Obligatoire. Nom de variable valide contenant les données écrites sur le disque.

RecordNumber: Int64

Optionnel. Numéro de l'enregistrement (fichiers ouverts en mode Random) ou de l'octet (fichiers ouverts en mode Binary) par lequel l'écriture débute.

Exceptions

ArgumentException

RecordNumber< 1 et différent de -1.

IOException

Le mode de fichier n’est pas valide.

Exemples

Cet exemple utilise la FilePut fonction pour écrire des données dans un fichier. Cinq enregistrements de la structure Person sont écrits dans le fichier.

Structure Person
    Public ID As Integer
    Public Name As String
End Structure

Sub WriteData()
    Dim PatientRecord As Person
    Dim recordNumber As Integer
    '    Open file for random access.
    FileOpen(1, "C:\TESTFILE.txt", OpenMode.Binary)
    ' Loop 5 times.
    For recordNumber = 1 To 5
        ' Define ID.
        PatientRecord.ID = recordNumber
        ' Create a string.
        PatientRecord.Name = "Name " & recordNumber
        ' Write record to file.
        FilePut(1, PatientRecord)
    Next recordNumber
    FileClose(1)
End Sub

Remarques

FilePut est valide uniquement en Random mode et Binary .

Les données écrites avec FilePut sont généralement lues à partir d’un fichier à l’aide de FileGet.

Le premier enregistrement ou octet d’un fichier se trouve à la position 1, le deuxième enregistrement ou octet est à la position 2, et ainsi de suite. Si vous omettez RecordNumber, l’enregistrement ou l’octet suivant après la dernière FileGet fonction ou FilePut pointée par la dernière Seek fonction est écrit.

L’argument StringIsFixedLength détermine si la fonction interprète les chaînes comme une longueur variable ou fixe. FilePut n’écrit pas le descripteur de longueur lorsque l’argument est True. Si vous utilisez StringIsFixedLength = True avec FilePut, vous devez faire de même avec FileGet, et vous devez vous assurer que la chaîne est initialisée à la longueur attendue.

Mode aléatoire

Pour les fichiers ouverts en Random mode, les règles suivantes s’appliquent :

Si la longueur des données en cours d’écriture est inférieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, FilePut écrit les enregistrements suivants sur les limites de longueur d’enregistrement. L’espace entre la fin d’un enregistrement et le début de l’enregistrement suivant est rempli avec le contenu existant de la mémoire tampon de fichier. Étant donné que la quantité de données de remplissage ne peut pas être déterminée avec certitude, il est généralement judicieux de faire en sorte que la longueur de l’enregistrement corresponde à la longueur des données en cours d’écriture. Si la longueur des données en cours d’écriture est supérieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, une exception est levée.
Si la variable en cours d’écriture est une chaîne, FilePut écrit un descripteur de deux octets qui contient la longueur de chaîne, puis écrit les données qui vont dans la variable. Par conséquent, la longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure d’au moins deux octets à la longueur réelle de la chaîne.
Si la variable en cours d’écriture est un objet qui contient un type numérique, FilePut écrit deux octets identifiant le VarType de l’objet, puis écrit la variable. Par exemple, lors de l’écriture d’un objet qui contient un entier, FilePut écrit six octets : deux octets qui identifient l’objet sous la forme VarType(3) (Integer) et quatre octets qui contiennent les données. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins deux octets au nombre d’octets requis pour stocker la variable.
Si la variable en cours d’écriture est un objet qui contient une chaîne, FilePut écrit un descripteur de deux octets identifiant le VarType(8) de l’objet, un descripteur de deux octets indiquant la longueur de la chaîne, puis écrit les données de chaîne. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins quatre octets à la longueur réelle de la chaîne. Si vous souhaitez placer une chaîne sans le descripteur, vous devez passer True au StringIsFixedLength paramètre , et la chaîne que vous lisez doit avoir la longueur correcte.
Si la variable en cours d’écriture est un tableau, vous avez le choix d’écrire ou non un descripteur pour la taille et les dimensions du tableau. Visual Basic 6.0 et les versions antérieures écrivent le descripteur de fichier pour un tableau dynamique, mais pas pour un tableau de taille fixe. Par défaut, Visual Basic 2005 n’écrit pas le descripteur. Pour écrire le descripteur, définissez le paramètre sur ArrayIsDynamicTrue. Lors de l’écriture du tableau, vous devez correspondre à la façon dont le tableau sera lu ; s’il est lu avec le descripteur, vous devez écrire le descripteur. Le descripteur spécifie le rang du tableau, la taille et les limites inférieures pour chaque classement. Sa longueur est égale à 2 plus 8 fois le nombre de dimensions : (2 + 8 * NumberOfDimensions). La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la somme de tous les octets requis pour écrire les données du tableau et le descripteur de tableau. Par exemple, la déclaration de tableau suivante nécessite 218 octets lorsque le tableau est écrit sur le disque.
```
Dim MyArray(4, 9) As Integer
```
Si la variable en cours d’écriture est un autre type de variable (et non une chaîne de longueur variable ou un objet), FilePut écrit uniquement les données de la variable. La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la longueur des données en cours d’écriture.
FilePut écrit des éléments de structures comme si chacun d’eux était écrit individuellement, sauf qu’il n’y a pas de remplissage entre les éléments. L’attribut VBFixedString peut être appliqué aux champs de chaîne dans les structures pour indiquer la taille de la chaîne lors de l’écriture sur disque.

Notes

Les champs de chaîne qui ont plus d’octets que spécifié par l’attribut VBFixedString sont tronqués lorsqu’ils sont écrits sur le disque,

Mode binaire

Pour les fichiers ouverts en Binary mode, la Random plupart des règles de mode s’appliquent, à quelques exceptions près. Les règles suivantes pour les fichiers ouverts en Binary mode diffèrent des règles du Random mode :

La RecordLength clause dans la FileOpen fonction n’a aucun effet. FilePut écrit toutes les variables sur le disque de façon contiguë, c’est-à-dire sans remplissage entre les enregistrements.
Pour tout tableau autre qu’un tableau dans une structure, FilePut écrit uniquement les données. Aucun descripteur n’est écrit.
FilePut écrit des chaînes de longueur variable qui ne sont pas des éléments de structures sans le descripteur de longueur de deux octets. Le nombre d’octets écrits est égal au nombre de caractères dans la chaîne. Par exemple, les instructions suivantes écrivent 11 octets dans le numéro de fichier 1 :
```
Dim hellow As String = "Hello World"
FilePut(1, hellow)
```
L’écriture dans un fichier à l’aide de la FilePut fonction nécessite un Write accès à partir de l’énumération FileIOPermissionAccess .

Voir aussi

S’applique à

FilePut(Int32, String, Int64, Boolean)

Source:: FileSystem.vb

Source:: FileSystem.vb

Source:: FileSystem.vb

public static void FilePut (int FileNumber, string Value, long RecordNumber = -1, bool StringIsFixedLength = false);

static member FilePut : int * string * int64 * bool -> unit

Public Sub FilePut (FileNumber As Integer, Value As String, Optional RecordNumber As Long = -1, Optional StringIsFixedLength As Boolean = false)

Paramètres

FileNumber: Int32

Obligatoire. N’importe quel numéro de fichier valide.

Value: String

Obligatoire. Nom de variable valide contenant les données écrites sur le disque.

RecordNumber: Int64

Optionnel. Numéro de l'enregistrement (fichiers ouverts en mode Random) ou de l'octet (fichiers ouverts en mode Binary) par lequel l'écriture débute.

StringIsFixedLength: Boolean

Optionnel. S'applique uniquement lors de l'écriture d'une chaîne. Spécifie s'il faut écrire, sur le fichier, un descripteur de longueur de chaîne à deux octets pour la chaîne. La valeur par défaut est False.

Exceptions

ArgumentException

RecordNumber< 1 et différent de -1.

IOException

Le mode de fichier n’est pas valide.

Exemples

Cet exemple utilise la FilePut fonction pour écrire des données dans un fichier. Cinq enregistrements de la structure Person sont écrits dans le fichier.

Structure Person
    Public ID As Integer
    Public Name As String
End Structure

Sub WriteData()
    Dim PatientRecord As Person
    Dim recordNumber As Integer
    '    Open file for random access.
    FileOpen(1, "C:\TESTFILE.txt", OpenMode.Binary)
    ' Loop 5 times.
    For recordNumber = 1 To 5
        ' Define ID.
        PatientRecord.ID = recordNumber
        ' Create a string.
        PatientRecord.Name = "Name " & recordNumber
        ' Write record to file.
        FilePut(1, PatientRecord)
    Next recordNumber
    FileClose(1)
End Sub

Remarques

FilePut est valide uniquement en Random mode et Binary .

Les données écrites avec FilePut sont généralement lues à partir d’un fichier à l’aide de FileGet.

Mode aléatoire

Pour les fichiers ouverts en Random mode, les règles suivantes s’appliquent :

Si la longueur des données en cours d’écriture est inférieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, FilePut écrit les enregistrements suivants sur les limites de longueur d’enregistrement. L’espace entre la fin d’un enregistrement et le début de l’enregistrement suivant est rempli avec le contenu existant de la mémoire tampon de fichier. Étant donné que la quantité de données de remplissage ne peut pas être déterminée avec certitude, il est généralement judicieux de faire en sorte que la longueur de l’enregistrement corresponde à la longueur des données en cours d’écriture. Si la longueur des données en cours d’écriture est supérieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, une exception est levée.
Si la variable en cours d’écriture est une chaîne, FilePut écrit un descripteur de deux octets qui contient la longueur de chaîne, puis écrit les données qui vont dans la variable. Par conséquent, la longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure d’au moins deux octets à la longueur réelle de la chaîne.
Si la variable en cours d’écriture est un objet qui contient un type numérique, FilePut écrit deux octets identifiant le VarType de l’objet, puis écrit la variable. Par exemple, lors de l’écriture d’un objet qui contient un entier, FilePut écrit six octets : deux octets qui identifient l’objet sous la forme VarType(3) (Integer) et quatre octets qui contiennent les données. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins deux octets au nombre d’octets requis pour stocker la variable.
Si la variable en cours d’écriture est un objet qui contient une chaîne, FilePut écrit un descripteur de deux octets identifiant le VarType(8) de l’objet, un descripteur de deux octets indiquant la longueur de la chaîne, puis écrit les données de chaîne. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins quatre octets à la longueur réelle de la chaîne. Si vous souhaitez placer une chaîne sans le descripteur, vous devez passer True au StringIsFixedLength paramètre , et la chaîne que vous lisez doit avoir la longueur correcte.
Si la variable en cours d’écriture est un tableau, vous avez le choix d’écrire ou non un descripteur pour la taille et les dimensions du tableau. Visual Basic 6.0 et les versions antérieures écrivent le descripteur de fichier pour un tableau dynamique, mais pas pour un tableau de taille fixe. Par défaut, Visual Basic 2005 n’écrit pas le descripteur. Pour écrire le descripteur, définissez le paramètre sur ArrayIsDynamicTrue. Lors de l’écriture du tableau, vous devez correspondre à la façon dont le tableau sera lu ; s’il est lu avec le descripteur, vous devez écrire le descripteur. Le descripteur spécifie le rang du tableau, la taille et les limites inférieures pour chaque classement. Sa longueur est égale à 2 plus 8 fois le nombre de dimensions : (2 + 8 * NumberOfDimensions). La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la somme de tous les octets requis pour écrire les données du tableau et le descripteur de tableau. Par exemple, la déclaration de tableau suivante nécessite 218 octets lorsque le tableau est écrit sur le disque.
```
Dim MyArray(4, 9) As Integer
```
Si la variable en cours d’écriture est un autre type de variable (et non une chaîne de longueur variable ou un objet), FilePut écrit uniquement les données de la variable. La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la longueur des données en cours d’écriture.
FilePut écrit des éléments de structures comme si chacun d’eux était écrit individuellement, sauf qu’il n’y a pas de remplissage entre les éléments. L’attribut VBFixedString peut être appliqué aux champs de chaîne dans les structures pour indiquer la taille de la chaîne lors de l’écriture sur disque.

Notes

Les champs de chaîne qui ont plus d’octets que spécifié par l’attribut VBFixedString sont tronqués lorsqu’ils sont écrits sur le disque,

Mode binaire

La RecordLength clause dans la FileOpen fonction n’a aucun effet. FilePut écrit toutes les variables sur le disque de façon contiguë, c’est-à-dire sans remplissage entre les enregistrements.
Pour tout tableau autre qu’un tableau dans une structure, FilePut écrit uniquement les données. Aucun descripteur n’est écrit.
FilePut écrit des chaînes de longueur variable qui ne sont pas des éléments de structures sans le descripteur de longueur de deux octets. Le nombre d’octets écrits est égal au nombre de caractères dans la chaîne. Par exemple, les instructions suivantes écrivent 11 octets dans le numéro de fichier 1 :
```
Dim hellow As String = "Hello World"
FilePut(1, hellow)
```
L’écriture dans un fichier à l’aide de la FilePut fonction nécessite un Write accès à partir de l’énumération FileIOPermissionAccess .

Voir aussi

S’applique à

FilePut(Object, Object, Object)

Source:: FileSystem.vb

Source:: FileSystem.vb

Source:: FileSystem.vb

Attention

This member has been deprecated. Please use FilePutObject to write Object types, or coerce FileNumber and RecordNumber to Integer for writing non-Object types. http://go.microsoft.com/fwlink/?linkid=14202

Attention

FileSystem.FilePut has been deprecated. Use FilePutObject to write Object types, or coerce FileNumber and RecordNumber to Integer for writing non-Object types.

Attention

Use FilePutObject to write Object types, or coerce FileNumber and RecordNumber to Integer for writing non-Object types

public:
 static void FilePut(System::Object ^ FileNumber, System::Object ^ Value, System::Object ^ RecordNumber);

[System.Obsolete("This member has been deprecated. Please use FilePutObject to write Object types, or coerce FileNumber and RecordNumber to Integer for writing non-Object types. http://go.microsoft.com/fwlink/?linkid=14202")]
public static void FilePut (object FileNumber, object Value, object RecordNumber);

[System.Obsolete("FileSystem.FilePut has been deprecated. Use FilePutObject to write Object types, or coerce FileNumber and RecordNumber to Integer for writing non-Object types.")]
public static void FilePut (object FileNumber, object Value, object RecordNumber);

[System.Obsolete("Use FilePutObject to write Object types, or coerce FileNumber and RecordNumber to Integer for writing non-Object types")]
public static void FilePut (object FileNumber, object Value, object RecordNumber = -1);

[System.Obsolete("This member has been deprecated. Please use FilePutObject to write Object types, or coerce FileNumber and RecordNumber to Integer for writing non-Object types. http://go.microsoft.com/fwlink/?linkid=14202")]
public static void FilePut (object FileNumber, object Value, object RecordNumber = -1);

[<System.Obsolete("This member has been deprecated. Please use FilePutObject to write Object types, or coerce FileNumber and RecordNumber to Integer for writing non-Object types. http://go.microsoft.com/fwlink/?linkid=14202")>]
static member FilePut : obj * obj * obj -> unit

[<System.Obsolete("FileSystem.FilePut has been deprecated. Use FilePutObject to write Object types, or coerce FileNumber and RecordNumber to Integer for writing non-Object types.")>]
static member FilePut : obj * obj * obj -> unit

[<System.Obsolete("Use FilePutObject to write Object types, or coerce FileNumber and RecordNumber to Integer for writing non-Object types")>]
static member FilePut : obj * obj * obj -> unit

Public Sub FilePut (FileNumber As Object, Value As Object, RecordNumber As Object)

Public Sub FilePut (FileNumber As Object, Value As Object, Optional RecordNumber As Object = -1)

Paramètres

FileNumber: Object

Obligatoire. N’importe quel numéro de fichier valide.

Value: Object

Obligatoire. Nom de variable valide contenant les données écrites sur le disque.

RecordNumber: Object

Optionnel. Numéro de l'enregistrement (fichiers ouverts en mode Random) ou de l'octet (fichiers ouverts en mode Binary) par lequel l'écriture débute.

Attributs: ObsoleteAttribute

Exceptions

ArgumentException

RecordNumber< 1 et différent de -1.

IOException

Le mode de fichier n’est pas valide.

Exemples

Cet exemple utilise la FilePut fonction pour écrire des données dans un fichier. Cinq enregistrements de la structure Person sont écrits dans le fichier.

Structure Person
    Public ID As Integer
    Public Name As String
End Structure

Sub WriteData()
    Dim PatientRecord As Person
    Dim recordNumber As Integer
    '    Open file for random access.
    FileOpen(1, "C:\TESTFILE.txt", OpenMode.Binary)
    ' Loop 5 times.
    For recordNumber = 1 To 5
        ' Define ID.
        PatientRecord.ID = recordNumber
        ' Create a string.
        PatientRecord.Name = "Name " & recordNumber
        ' Write record to file.
        FilePut(1, PatientRecord)
    Next recordNumber
    FileClose(1)
End Sub

Remarques

FilePut est valide uniquement en Random mode et Binary .

Les données écrites avec FilePut sont généralement lues à partir d’un fichier à l’aide de FileGet.

Mode aléatoire

Pour les fichiers ouverts en Random mode, les règles suivantes s’appliquent :

Si la longueur des données en cours d’écriture est inférieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, FilePut écrit les enregistrements suivants sur les limites de longueur d’enregistrement. L’espace entre la fin d’un enregistrement et le début de l’enregistrement suivant est rempli avec le contenu existant de la mémoire tampon de fichier. Étant donné que la quantité de données de remplissage ne peut pas être déterminée avec certitude, il est généralement judicieux de faire en sorte que la longueur de l’enregistrement corresponde à la longueur des données en cours d’écriture. Si la longueur des données en cours d’écriture est supérieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, une exception est levée.
Si la variable en cours d’écriture est une chaîne, FilePut écrit un descripteur de deux octets qui contient la longueur de chaîne, puis écrit les données qui vont dans la variable. Par conséquent, la longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure d’au moins deux octets à la longueur réelle de la chaîne.
Si la variable en cours d’écriture est un objet qui contient un type numérique, FilePut écrit deux octets identifiant le VarType de l’objet, puis écrit la variable. Par exemple, lors de l’écriture d’un objet qui contient un entier, FilePut écrit six octets : deux octets qui identifient l’objet sous la forme VarType(3) (Integer) et quatre octets qui contiennent les données. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins deux octets au nombre d’octets requis pour stocker la variable.
Si la variable en cours d’écriture est un objet qui contient une chaîne, FilePut écrit un descripteur de deux octets identifiant le VarType(8) de l’objet, un descripteur de deux octets indiquant la longueur de la chaîne, puis écrit les données de chaîne. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins quatre octets à la longueur réelle de la chaîne. Si vous souhaitez placer une chaîne sans le descripteur, vous devez passer True au StringIsFixedLength paramètre , et la chaîne que vous lisez doit avoir la longueur correcte.
Si la variable en cours d’écriture est un tableau, vous avez le choix d’écrire ou non un descripteur pour la taille et les dimensions du tableau. Visual Basic 6.0 et les versions antérieures écrivent le descripteur de fichier pour un tableau dynamique, mais pas pour un tableau de taille fixe. Par défaut, Visual Basic 2005 n’écrit pas le descripteur. Pour écrire le descripteur, définissez le paramètre sur ArrayIsDynamicTrue. Lors de l’écriture du tableau, vous devez correspondre à la façon dont le tableau sera lu ; s’il est lu avec le descripteur, vous devez écrire le descripteur. Le descripteur spécifie le rang du tableau, la taille et les limites inférieures pour chaque classement. Sa longueur est égale à 2 plus 8 fois le nombre de dimensions : (2 + 8 * NumberOfDimensions). La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la somme de tous les octets requis pour écrire les données du tableau et le descripteur de tableau. Par exemple, la déclaration de tableau suivante nécessite 218 octets lorsque le tableau est écrit sur le disque.
```
Dim MyArray(4, 9) As Integer
```
Si la variable en cours d’écriture est un autre type de variable (et non une chaîne de longueur variable ou un objet), FilePut écrit uniquement les données de la variable. La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la longueur des données en cours d’écriture.
FilePut écrit des éléments de structures comme si chacun d’eux était écrit individuellement, sauf qu’il n’y a pas de remplissage entre les éléments. L’attribut VBFixedString peut être appliqué aux champs de chaîne dans les structures pour indiquer la taille de la chaîne lors de l’écriture sur disque.

Notes

Les champs de chaîne qui ont plus d’octets que spécifié par l’attribut VBFixedString sont tronqués lorsqu’ils sont écrits sur le disque,

Mode binaire

La RecordLength clause dans la FileOpen fonction n’a aucun effet. FilePut écrit toutes les variables sur le disque de façon contiguë, c’est-à-dire sans remplissage entre les enregistrements.
Pour tout tableau autre qu’un tableau dans une structure, FilePut écrit uniquement les données. Aucun descripteur n’est écrit.
FilePut écrit des chaînes de longueur variable qui ne sont pas des éléments de structures sans le descripteur de longueur de deux octets. Le nombre d’octets écrits est égal au nombre de caractères dans la chaîne. Par exemple, les instructions suivantes écrivent 11 octets dans le numéro de fichier 1 :
```
Dim hellow As String = "Hello World"
FilePut(1, hellow)
```
L’écriture dans un fichier à l’aide de la FilePut fonction nécessite un Write accès à partir de l’énumération FileIOPermissionAccess .

Voir aussi

S’applique à

FilePut(Int32, ValueType, Int64)

Source:: FileSystem.vb

Source:: FileSystem.vb

Source:: FileSystem.vb

public static void FilePut (int FileNumber, ValueType Value, long RecordNumber = -1);

static member FilePut : int * ValueType * int64 -> unit

Public Sub FilePut (FileNumber As Integer, Value As ValueType, Optional RecordNumber As Long = -1)

Paramètres

FileNumber: Int32

Obligatoire. N’importe quel numéro de fichier valide.

Value: ValueType

Obligatoire. Nom de variable valide contenant les données écrites sur le disque.

RecordNumber: Int64

Optionnel. Numéro de l'enregistrement (fichiers ouverts en mode Random) ou de l'octet (fichiers ouverts en mode Binary) par lequel l'écriture débute.

Exceptions

ArgumentException

RecordNumber< 1 et différent de -1.

IOException

Le mode de fichier n’est pas valide.

Exemples

Cet exemple utilise la FilePut fonction pour écrire des données dans un fichier. Cinq enregistrements de la structure Person sont écrits dans le fichier.

Structure Person
    Public ID As Integer
    Public Name As String
End Structure

Sub WriteData()
    Dim PatientRecord As Person
    Dim recordNumber As Integer
    '    Open file for random access.
    FileOpen(1, "C:\TESTFILE.txt", OpenMode.Binary)
    ' Loop 5 times.
    For recordNumber = 1 To 5
        ' Define ID.
        PatientRecord.ID = recordNumber
        ' Create a string.
        PatientRecord.Name = "Name " & recordNumber
        ' Write record to file.
        FilePut(1, PatientRecord)
    Next recordNumber
    FileClose(1)
End Sub

Remarques

FilePut est valide uniquement en Random mode et Binary .

Les données écrites avec FilePut sont généralement lues à partir d’un fichier à l’aide de FileGet.

Mode aléatoire

Pour les fichiers ouverts en Random mode, les règles suivantes s’appliquent :

Si la longueur des données en cours d’écriture est inférieure à la longueur spécifiée dans laRecordLength clause de la FileOpen fonction, FilePut écrit les enregistrements suivants sur les limites de longueur d’enregistrement. L’espace entre la fin d’un enregistrement et le début de l’enregistrement suivant est complété avec le contenu existant de la mémoire tampon de fichier. Étant donné que la quantité de données de remplissage ne peut pas être déterminée avec certitude, il est généralement judicieux d’avoir la longueur de l’enregistrement correspondant à la longueur des données en cours d’écriture. Si la longueur des données en cours d’écriture est supérieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, une exception est levée.
Si la variable en cours d’écriture est une chaîne, FilePut écrit un descripteur de deux octets qui contient la longueur de chaîne, puis écrit les données qui vont dans la variable. Par conséquent, la longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure d’au moins deux octets à la longueur réelle de la chaîne.
Si la variable en cours d’écriture est un objet qui contient un type numérique, FilePut écrit deux octets identifiant le VarType de l’objet, puis écrit la variable. Par exemple, lors de l’écriture d’un objet qui contient un entier, FilePut écrit six octets : deux octets qui identifient l’objet comme VarType(3) (Integer) et quatre octets qui contiennent les données. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins deux octets au nombre d’octets requis pour stocker la variable.
Si la variable en cours d’écriture est un objet qui contient une chaîne, FilePut écrit un descripteur de deux octets identifiant le VarType(8) de l’objet, un descripteur de deux octets indiquant la longueur de la chaîne, puis écrit les données de chaîne. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins quatre octets à la longueur réelle de la chaîne. Si vous souhaitez placer une chaîne sans le descripteur, vous devez passer True au StringIsFixedLength paramètre, et la chaîne que vous lisez doit avoir la longueur correcte.
Si la variable en cours d’écriture est un tableau, vous avez le choix d’écrire ou non un descripteur pour la taille et les dimensions du tableau. Visual Basic 6.0 et les versions antérieures écrivent le descripteur de fichier pour un tableau dynamique, mais pas pour un tableau de taille fixe. Par défaut, Visual Basic 2005 n’écrit pas le descripteur. Pour écrire le descripteur, définissez le paramètre sur ArrayIsDynamicTrue. Lors de l’écriture du tableau, vous devez correspondre à la façon dont le tableau sera lu ; s’il est lu avec le descripteur, vous devez écrire le descripteur. Le descripteur spécifie le rang du tableau, la taille et les limites inférieures pour chaque classement. Sa longueur est égale à 2 plus 8 fois le nombre de dimensions : (2 + 8 * NumberOfDimensions). La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la somme de tous les octets nécessaires pour écrire les données du tableau et le descripteur de tableau. Par exemple, la déclaration de tableau suivante nécessite 218 octets lorsque le tableau est écrit sur le disque.
```
Dim MyArray(4, 9) As Integer
```
Si la variable en cours d’écriture est un autre type de variable (pas une chaîne de longueur variable ou un objet), FilePut écrit uniquement les données de variable. La longueur de l’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la longueur des données en cours d’écriture.
FilePut écrit des éléments de structures comme si chacun d’eux était écrit individuellement, sauf qu’il n’y a pas de remplissage entre les éléments. L’attribut VBFixedString peut être appliqué aux champs de chaîne dans les structures pour indiquer la taille de la chaîne en cas d’écriture sur disque.

Notes

Les champs de chaîne qui ont plus d’octets que spécifiés par l’attribut VBFixedString sont tronqués lorsqu’ils sont écrits sur le disque,

Mode binaire

La RecordLength clause de la FileOpen fonction n’a aucun effet. FilePut écrit toutes les variables sur le disque de manière contiguë, c’est-à-dire sans remplissage entre les enregistrements.
Pour tout tableau autre qu’un tableau d’une structure, FilePut écrit uniquement les données. Aucun descripteur n’est écrit.
FilePut écrit des chaînes de longueur variable qui ne sont pas des éléments de structures sans le descripteur de longueur de deux octets. Le nombre d’octets écrits est égal au nombre de caractères dans la chaîne. Par exemple, les instructions suivantes écrivent 11 octets dans le numéro de fichier 1 :
```
Dim hellow As String = "Hello World"
FilePut(1, hellow)
```
L’écriture dans un fichier à l’aide de la FilePut fonction nécessite l’accès Write à partir de l’énumération FileIOPermissionAccess .

Voir aussi

S’applique à

FilePut(Int32, Single, Int64)

Source:: FileSystem.vb

Source:: FileSystem.vb

Source:: FileSystem.vb

public static void FilePut (int FileNumber, float Value, long RecordNumber = -1);

static member FilePut : int * single * int64 -> unit

Public Sub FilePut (FileNumber As Integer, Value As Single, Optional RecordNumber As Long = -1)

Paramètres

FileNumber: Int32

Obligatoire. N’importe quel numéro de fichier valide.

Value: Single

Obligatoire. Nom de variable valide contenant les données écrites sur le disque.

RecordNumber: Int64

Optionnel. Numéro de l'enregistrement (fichiers ouverts en mode Random) ou de l'octet (fichiers ouverts en mode Binary) par lequel l'écriture débute.

Exceptions

ArgumentException

RecordNumber< 1 et différent de -1.

IOException

Le mode de fichier n’est pas valide.

Exemples

Cet exemple utilise la FilePut fonction pour écrire des données dans un fichier. Cinq enregistrements de la structure Person sont écrits dans le fichier.

Structure Person
    Public ID As Integer
    Public Name As String
End Structure

Sub WriteData()
    Dim PatientRecord As Person
    Dim recordNumber As Integer
    '    Open file for random access.
    FileOpen(1, "C:\TESTFILE.txt", OpenMode.Binary)
    ' Loop 5 times.
    For recordNumber = 1 To 5
        ' Define ID.
        PatientRecord.ID = recordNumber
        ' Create a string.
        PatientRecord.Name = "Name " & recordNumber
        ' Write record to file.
        FilePut(1, PatientRecord)
    Next recordNumber
    FileClose(1)
End Sub

Remarques

FilePut est valide uniquement en Random mode et Binary .

Les données écrites avec FilePut sont généralement lues à partir d’un fichier à l’aide de FileGet.

Le premier enregistrement ou octet d’un fichier se trouve à la position 1, le deuxième enregistrement ou octet se trouve à la position 2, et ainsi de suite. Si vous omettez RecordNumber, l’enregistrement ou l’octet suivant après l’écriture du dernier FileGet ou de la fonction ou FilePut pointé par la dernière Seek fonction.

L’argument StringIsFixedLength contrôle si la fonction interprète les chaînes comme une longueur variable ou fixe. FilePut n’écrit pas le descripteur de longueur lorsque l’argument est True. Si vous utilisez StringIsFixedLength = True avec FilePut, vous devez faire de même avec FileGet, et vous devez vous assurer que la chaîne est initialisée à la longueur attendue.

Mode aléatoire

Pour les fichiers ouverts en Random mode, les règles suivantes s’appliquent :

Si la longueur des données en cours d’écriture est inférieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, FilePut écrit les enregistrements suivants sur les limites de longueur d’enregistrement. L’espace entre la fin d’un enregistrement et le début de l’enregistrement suivant est complété avec le contenu existant de la mémoire tampon de fichier. Étant donné que la quantité de données de remplissage ne peut pas être déterminée avec certitude, il est généralement judicieux d’avoir la longueur de l’enregistrement correspondant à la longueur des données en cours d’écriture. Si la longueur des données en cours d’écriture est supérieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, une exception est levée.
Si la variable en cours d’écriture est une chaîne, FilePut écrit un descripteur de deux octets qui contient la longueur de chaîne, puis écrit les données qui vont dans la variable. Par conséquent, la longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure d’au moins deux octets à la longueur réelle de la chaîne.
Si la variable en cours d’écriture est un objet qui contient un type numérique, FilePut écrit deux octets identifiant le VarType de l’objet, puis écrit la variable. Par exemple, lors de l’écriture d’un objet qui contient un entier, FilePut écrit six octets : deux octets qui identifient l’objet comme VarType(3) (Integer) et quatre octets qui contiennent les données. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins deux octets au nombre d’octets requis pour stocker la variable.
Si la variable en cours d’écriture est un objet qui contient une chaîne, FilePut écrit un descripteur de deux octets identifiant le VarType(8) de l’objet, un descripteur de deux octets indiquant la longueur de la chaîne, puis écrit les données de chaîne. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins quatre octets à la longueur réelle de la chaîne. Si vous souhaitez placer une chaîne sans le descripteur, vous devez passer True au StringIsFixedLength paramètre, et la chaîne que vous lisez doit avoir la longueur correcte.
Si la variable en cours d’écriture est un tableau, vous avez le choix d’écrire ou non un descripteur pour la taille et les dimensions du tableau. Visual Basic 6.0 et les versions antérieures écrivent le descripteur de fichier pour un tableau dynamique, mais pas pour un tableau de taille fixe. Par défaut, Visual Basic 2005 n’écrit pas le descripteur. Pour écrire le descripteur, définissez le paramètre sur ArrayIsDynamicTrue. Lors de l’écriture du tableau, vous devez correspondre à la façon dont le tableau sera lu ; s’il est lu avec le descripteur, vous devez écrire le descripteur. Le descripteur spécifie le rang du tableau, la taille et les limites inférieures pour chaque classement. Sa longueur est égale à 2 plus 8 fois le nombre de dimensions : (2 + 8 * NumberOfDimensions). La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la somme de tous les octets nécessaires pour écrire les données du tableau et le descripteur de tableau. Par exemple, la déclaration de tableau suivante nécessite 218 octets lorsque le tableau est écrit sur le disque.
```
Dim MyArray(4, 9) As Integer
```
Si la variable en cours d’écriture est un autre type de variable (pas une chaîne de longueur variable ou un objet), FilePut écrit uniquement les données de variable. La longueur de l’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la longueur des données en cours d’écriture.
FilePut écrit des éléments de structures comme si chacun d’eux était écrit individuellement, sauf qu’il n’y a pas de remplissage entre les éléments. L’attribut VBFixedString peut être appliqué aux champs de chaîne dans les structures pour indiquer la taille de la chaîne en cas d’écriture sur disque.

Notes

Les champs de chaîne qui ont plus d’octets que spécifiés par l’attribut VBFixedString sont tronqués lorsqu’ils sont écrits sur le disque,

Mode binaire

La RecordLength clause de la FileOpen fonction n’a aucun effet. FilePut écrit toutes les variables sur le disque de manière contiguë, c’est-à-dire sans remplissage entre les enregistrements.
Pour tout tableau autre qu’un tableau d’une structure, FilePut écrit uniquement les données. Aucun descripteur n’est écrit.
FilePut écrit des chaînes de longueur variable qui ne sont pas des éléments de structures sans le descripteur de longueur de deux octets. Le nombre d’octets écrits est égal au nombre de caractères dans la chaîne. Par exemple, les instructions suivantes écrivent 11 octets dans le numéro de fichier 1 :
```
Dim hellow As String = "Hello World"
FilePut(1, hellow)
```
L’écriture dans un fichier à l’aide de la FilePut fonction nécessite l’accès Write à partir de l’énumération FileIOPermissionAccess .

Voir aussi

S’applique à

FilePut(Int32, Int32, Int64)

Source:: FileSystem.vb

Source:: FileSystem.vb

Source:: FileSystem.vb

public static void FilePut (int FileNumber, int Value, long RecordNumber = -1);

static member FilePut : int * int * int64 -> unit

Public Sub FilePut (FileNumber As Integer, Value As Integer, Optional RecordNumber As Long = -1)

Paramètres

FileNumber: Int32

Obligatoire. N’importe quel numéro de fichier valide.

Value: Int32

Obligatoire. Nom de variable valide contenant les données écrites sur le disque.

RecordNumber: Int64

Optionnel. Numéro de l'enregistrement (fichiers ouverts en mode Random) ou de l'octet (fichiers ouverts en mode Binary) par lequel l'écriture débute.

Exceptions

ArgumentException

RecordNumber< 1 et différent de -1.

IOException

Le mode de fichier n’est pas valide.

Exemples

Cet exemple utilise la FilePut fonction pour écrire des données dans un fichier. Cinq enregistrements de la structure Person sont écrits dans le fichier.

Structure Person
    Public ID As Integer
    Public Name As String
End Structure

Sub WriteData()
    Dim PatientRecord As Person
    Dim recordNumber As Integer
    '    Open file for random access.
    FileOpen(1, "C:\TESTFILE.txt", OpenMode.Binary)
    ' Loop 5 times.
    For recordNumber = 1 To 5
        ' Define ID.
        PatientRecord.ID = recordNumber
        ' Create a string.
        PatientRecord.Name = "Name " & recordNumber
        ' Write record to file.
        FilePut(1, PatientRecord)
    Next recordNumber
    FileClose(1)
End Sub

Remarques

FilePut est valide uniquement en Random mode et Binary .

Les données écrites avec FilePut sont généralement lues à partir d’un fichier à l’aide de FileGet.

Mode aléatoire

Pour les fichiers ouverts en Random mode, les règles suivantes s’appliquent :

Si la longueur des données en cours d’écriture est inférieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, FilePut écrit les enregistrements suivants sur les limites de longueur d’enregistrement. L’espace entre la fin d’un enregistrement et le début de l’enregistrement suivant est rempli avec le contenu existant de la mémoire tampon de fichier. Étant donné que la quantité de données de remplissage ne peut pas être déterminée avec certitude, il est généralement judicieux de faire en sorte que la longueur de l’enregistrement corresponde à la longueur des données en cours d’écriture. Si la longueur des données en cours d’écriture est supérieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, une exception est levée.
Si la variable en cours d’écriture est une chaîne, FilePut écrit un descripteur de deux octets qui contient la longueur de chaîne, puis écrit les données qui vont dans la variable. Par conséquent, la longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure d’au moins deux octets à la longueur réelle de la chaîne.
Si la variable en cours d’écriture est un objet qui contient un type numérique, FilePut écrit deux octets identifiant le VarType de l’objet, puis écrit la variable. Par exemple, lors de l’écriture d’un objet qui contient un entier, FilePut écrit six octets : deux octets qui identifient l’objet sous la forme VarType(3) (Integer) et quatre octets qui contiennent les données. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins deux octets au nombre d’octets requis pour stocker la variable.
Si la variable en cours d’écriture est un objet qui contient une chaîne, FilePut écrit un descripteur de deux octets identifiant le VarType(8) de l’objet, un descripteur de deux octets indiquant la longueur de la chaîne, puis écrit les données de chaîne. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins quatre octets à la longueur réelle de la chaîne. Si vous souhaitez placer une chaîne sans le descripteur, vous devez passer True au StringIsFixedLength paramètre , et la chaîne que vous lisez doit avoir la longueur correcte.
Si la variable en cours d’écriture est un tableau, vous avez le choix d’écrire ou non un descripteur pour la taille et les dimensions du tableau. Visual Basic 6.0 et les versions antérieures écrivent le descripteur de fichier pour un tableau dynamique, mais pas pour un tableau de taille fixe. Par défaut, Visual Basic 2005 n’écrit pas le descripteur. Pour écrire le descripteur, définissez le paramètre sur ArrayIsDynamicTrue. Lors de l’écriture du tableau, vous devez correspondre à la façon dont le tableau sera lu ; s’il est lu avec le descripteur, vous devez écrire le descripteur. Le descripteur spécifie le rang du tableau, la taille et les limites inférieures pour chaque classement. Sa longueur est égale à 2 plus 8 fois le nombre de dimensions : (2 + 8 * NumberOfDimensions). La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la somme de tous les octets requis pour écrire les données du tableau et le descripteur de tableau. Par exemple, la déclaration de tableau suivante nécessite 218 octets lorsque le tableau est écrit sur le disque.
```
Dim MyArray(4, 9) As Integer
```
Si la variable en cours d’écriture est un autre type de variable (et non une chaîne de longueur variable ou un objet), FilePut écrit uniquement les données de la variable. La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la longueur des données en cours d’écriture.
FilePut écrit des éléments de structures comme si chacun d’eux était écrit individuellement, sauf qu’il n’y a pas de remplissage entre les éléments. L’attribut VBFixedString peut être appliqué aux champs de chaîne dans les structures pour indiquer la taille de la chaîne lors de l’écriture sur disque.

Notes

Les champs de chaîne qui ont plus d’octets que spécifié par l’attribut VBFixedString sont tronqués lorsqu’ils sont écrits sur le disque,

Mode binaire

La RecordLength clause dans la FileOpen fonction n’a aucun effet. FilePut écrit toutes les variables sur le disque de façon contiguë, c’est-à-dire sans remplissage entre les enregistrements.
Pour tout tableau autre qu’un tableau dans une structure, FilePut écrit uniquement les données. Aucun descripteur n’est écrit.
FilePut écrit des chaînes de longueur variable qui ne sont pas des éléments de structures sans le descripteur de longueur de deux octets. Le nombre d’octets écrits est égal au nombre de caractères dans la chaîne. Par exemple, les instructions suivantes écrivent 11 octets dans le numéro de fichier 1 :
```
Dim hellow As String = "Hello World"
FilePut(1, hellow)
```
L’écriture dans un fichier à l’aide de la FilePut fonction nécessite un Write accès à partir de l’énumération FileIOPermissionAccess .

Voir aussi

S’applique à

FilePut(Int32, Array, Int64, Boolean, Boolean)

Source:: FileSystem.vb

Source:: FileSystem.vb

Source:: FileSystem.vb

public static void FilePut (int FileNumber, Array Value, long RecordNumber = -1, bool ArrayIsDynamic = false, bool StringIsFixedLength = false);

static member FilePut : int * Array * int64 * bool * bool -> unit

Public Sub FilePut (FileNumber As Integer, Value As Array, Optional RecordNumber As Long = -1, Optional ArrayIsDynamic As Boolean = false, Optional StringIsFixedLength As Boolean = false)

Paramètres

FileNumber: Int32

Obligatoire. N’importe quel numéro de fichier valide.

Value: Array

Obligatoire. Nom de variable valide contenant les données écrites sur le disque.

RecordNumber: Int64

Optionnel. Numéro de l'enregistrement (fichiers ouverts en mode Random) ou de l'octet (fichiers ouverts en mode Binary) par lequel l'écriture débute.

ArrayIsDynamic: Boolean

Optionnel. S'applique uniquement lors de l'écriture d'un tableau. Spécifie si le tableau est traité comme dynamique, et s'il faut écrire un descripteur de tableau pour la chaîne décrivant la longueur.

StringIsFixedLength: Boolean

Exceptions

ArgumentException

RecordNumber< 1 et différent de -1.

IOException

Le mode de fichier n’est pas valide.

Exemples

Cet exemple utilise la FilePut fonction pour écrire des données dans un fichier. Cinq enregistrements de la structure Person sont écrits dans le fichier.

Structure Person
    Public ID As Integer
    Public Name As String
End Structure

Sub WriteData()
    Dim PatientRecord As Person
    Dim recordNumber As Integer
    '    Open file for random access.
    FileOpen(1, "C:\TESTFILE.txt", OpenMode.Binary)
    ' Loop 5 times.
    For recordNumber = 1 To 5
        ' Define ID.
        PatientRecord.ID = recordNumber
        ' Create a string.
        PatientRecord.Name = "Name " & recordNumber
        ' Write record to file.
        FilePut(1, PatientRecord)
    Next recordNumber
    FileClose(1)
End Sub

Remarques

FilePut est valide uniquement en Random mode et Binary .

Les données écrites avec FilePut sont généralement lues à partir d’un fichier à l’aide de FileGet.

Mode aléatoire

Pour les fichiers ouverts en Random mode, les règles suivantes s’appliquent :

Si la longueur des données en cours d’écriture est inférieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, FilePut écrit les enregistrements suivants sur les limites de longueur d’enregistrement. L’espace entre la fin d’un enregistrement et le début de l’enregistrement suivant est rempli avec le contenu existant de la mémoire tampon de fichier. Étant donné que la quantité de données de remplissage ne peut pas être déterminée avec certitude, il est généralement judicieux de faire en sorte que la longueur de l’enregistrement corresponde à la longueur des données en cours d’écriture. Si la longueur des données en cours d’écriture est supérieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, une exception est levée.
Si la variable en cours d’écriture est une chaîne, FilePut écrit un descripteur de deux octets qui contient la longueur de chaîne, puis écrit les données qui vont dans la variable. Par conséquent, la longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure d’au moins deux octets à la longueur réelle de la chaîne.
Si la variable en cours d’écriture est un objet qui contient un type numérique, FilePut écrit deux octets identifiant le VarType de l’objet, puis écrit la variable. Par exemple, lors de l’écriture d’un objet qui contient un entier, FilePut écrit six octets : deux octets qui identifient l’objet sous la forme VarType(3) (Integer) et quatre octets qui contiennent les données. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins deux octets au nombre d’octets requis pour stocker la variable.
Si la variable en cours d’écriture est un objet qui contient une chaîne, FilePut écrit un descripteur de deux octets identifiant le VarType(8) de l’objet, un descripteur de deux octets indiquant la longueur de la chaîne, puis écrit les données de chaîne. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins quatre octets à la longueur réelle de la chaîne. Si vous souhaitez placer une chaîne sans le descripteur, vous devez passer True au StringIsFixedLength paramètre , et la chaîne que vous lisez doit avoir la longueur correcte.
Si la variable en cours d’écriture est un tableau, vous avez le choix d’écrire ou non un descripteur pour la taille et les dimensions du tableau. Visual Basic 6.0 et les versions antérieures écrivent le descripteur de fichier pour un tableau dynamique, mais pas pour un tableau de taille fixe. Par défaut, Visual Basic 2005 n’écrit pas le descripteur. Pour écrire le descripteur, définissez le paramètre sur ArrayIsDynamicTrue. Lors de l’écriture du tableau, vous devez correspondre à la façon dont le tableau sera lu ; s’il est lu avec le descripteur, vous devez écrire le descripteur. Le descripteur spécifie le rang du tableau, la taille et les limites inférieures pour chaque classement. Sa longueur est égale à 2 plus 8 fois le nombre de dimensions : (2 + 8 * NumberOfDimensions). La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la somme de tous les octets requis pour écrire les données du tableau et le descripteur de tableau. Par exemple, la déclaration de tableau suivante nécessite 218 octets lorsque le tableau est écrit sur le disque.
```
Dim MyArray(4, 9) As Integer
```
Si la variable en cours d’écriture est un autre type de variable (et non une chaîne de longueur variable ou un objet), FilePut écrit uniquement les données de la variable. La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la longueur des données en cours d’écriture.
FilePut écrit des éléments de structures comme si chacun d’eux était écrit individuellement, sauf qu’il n’y a pas de remplissage entre les éléments. L’attribut VBFixedString peut être appliqué aux champs de chaîne dans les structures pour indiquer la taille de la chaîne lors de l’écriture sur disque.

Notes

Les champs de chaîne qui ont plus d’octets que spécifié par l’attribut VBFixedString sont tronqués lorsqu’ils sont écrits sur le disque,

Mode binaire

La RecordLength clause dans la FileOpen fonction n’a aucun effet. FilePut écrit toutes les variables sur le disque de façon contiguë, c’est-à-dire sans remplissage entre les enregistrements.
Pour tout tableau autre qu’un tableau dans une structure, FilePut écrit uniquement les données. Aucun descripteur n’est écrit.
FilePut écrit des chaînes de longueur variable qui ne sont pas des éléments de structures sans le descripteur de longueur de deux octets. Le nombre d’octets écrits est égal au nombre de caractères dans la chaîne. Par exemple, les instructions suivantes écrivent 11 octets dans le numéro de fichier 1 :
```
Dim hellow As String = "Hello World"
FilePut(1, hellow)
```
L’écriture dans un fichier à l’aide de la FilePut fonction nécessite un Write accès à partir de l’énumération FileIOPermissionAccess .

Voir aussi

S’applique à

FilePut(Int32, Double, Int64)

Source:: FileSystem.vb

Source:: FileSystem.vb

Source:: FileSystem.vb

public static void FilePut (int FileNumber, double Value, long RecordNumber = -1);

static member FilePut : int * double * int64 -> unit

Public Sub FilePut (FileNumber As Integer, Value As Double, Optional RecordNumber As Long = -1)

Paramètres

FileNumber: Int32

Obligatoire. N’importe quel numéro de fichier valide.

Value: Double

Obligatoire. Nom de variable valide contenant les données écrites sur le disque.

RecordNumber: Int64

Optionnel. Numéro de l'enregistrement (fichiers ouverts en mode Random) ou de l'octet (fichiers ouverts en mode Binary) par lequel l'écriture débute.

Exceptions

ArgumentException

RecordNumber< 1 et différent de -1.

IOException

Le mode de fichier n’est pas valide.

Exemples

Cet exemple utilise la FilePut fonction pour écrire des données dans un fichier. Cinq enregistrements de la structure Person sont écrits dans le fichier.

Structure Person
    Public ID As Integer
    Public Name As String
End Structure

Sub WriteData()
    Dim PatientRecord As Person
    Dim recordNumber As Integer
    '    Open file for random access.
    FileOpen(1, "C:\TESTFILE.txt", OpenMode.Binary)
    ' Loop 5 times.
    For recordNumber = 1 To 5
        ' Define ID.
        PatientRecord.ID = recordNumber
        ' Create a string.
        PatientRecord.Name = "Name " & recordNumber
        ' Write record to file.
        FilePut(1, PatientRecord)
    Next recordNumber
    FileClose(1)
End Sub

Remarques

FilePut est valide uniquement en Random mode et Binary .

Les données écrites avec FilePut sont généralement lues à partir d’un fichier à l’aide de FileGet.

Mode aléatoire

Pour les fichiers ouverts en Random mode, les règles suivantes s’appliquent :

Si la longueur des données en cours d’écriture est inférieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, FilePut écrit les enregistrements suivants sur les limites de longueur d’enregistrement. L’espace entre la fin d’un enregistrement et le début de l’enregistrement suivant est rempli avec le contenu existant de la mémoire tampon de fichier. Étant donné que la quantité de données de remplissage ne peut pas être déterminée avec certitude, il est généralement judicieux de faire en sorte que la longueur de l’enregistrement corresponde à la longueur des données en cours d’écriture. Si la longueur des données en cours d’écriture est supérieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, une exception est levée.
Si la variable en cours d’écriture est une chaîne, FilePut écrit un descripteur de deux octets qui contient la longueur de chaîne, puis écrit les données qui vont dans la variable. Par conséquent, la longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure d’au moins deux octets à la longueur réelle de la chaîne.
Si la variable en cours d’écriture est un objet qui contient un type numérique, FilePut écrit deux octets identifiant le VarType de l’objet, puis écrit la variable. Par exemple, lors de l’écriture d’un objet qui contient un entier, FilePut écrit six octets : deux octets qui identifient l’objet sous la forme VarType(3) (Integer) et quatre octets qui contiennent les données. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins deux octets au nombre d’octets requis pour stocker la variable.
Si la variable en cours d’écriture est un objet qui contient une chaîne, FilePut écrit un descripteur de deux octets identifiant le VarType(8) de l’objet, un descripteur de deux octets indiquant la longueur de la chaîne, puis écrit les données de chaîne. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins quatre octets à la longueur réelle de la chaîne. Si vous souhaitez placer une chaîne sans le descripteur, vous devez passer True au StringIsFixedLength paramètre , et la chaîne que vous lisez doit avoir la longueur correcte.
Si la variable en cours d’écriture est un tableau, vous avez le choix d’écrire ou non un descripteur pour la taille et les dimensions du tableau. Visual Basic 6.0 et les versions antérieures écrivent le descripteur de fichier pour un tableau dynamique, mais pas pour un tableau de taille fixe. Par défaut, Visual Basic 2005 n’écrit pas le descripteur. Pour écrire le descripteur, définissez le paramètre sur ArrayIsDynamicTrue. Lors de l’écriture du tableau, vous devez correspondre à la façon dont le tableau sera lu ; s’il est lu avec le descripteur, vous devez écrire le descripteur. Le descripteur spécifie le rang du tableau, la taille et les limites inférieures pour chaque classement. Sa longueur est égale à 2 plus 8 fois le nombre de dimensions : (2 + 8 * NumberOfDimensions). La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la somme de tous les octets requis pour écrire les données du tableau et le descripteur de tableau. Par exemple, la déclaration de tableau suivante nécessite 218 octets lorsque le tableau est écrit sur le disque.
```
Dim MyArray(4, 9) As Integer
```
Si la variable en cours d’écriture est un autre type de variable (et non une chaîne de longueur variable ou un objet), FilePut écrit uniquement les données de la variable. La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la longueur des données en cours d’écriture.
FilePut écrit des éléments de structures comme si chacun d’eux était écrit individuellement, sauf qu’il n’y a pas de remplissage entre les éléments. L’attribut VBFixedString peut être appliqué aux champs de chaîne dans les structures pour indiquer la taille de la chaîne lors de l’écriture sur disque.

Notes

Les champs de chaîne qui ont plus d’octets que spécifié par l’attribut VBFixedString sont tronqués lorsqu’ils sont écrits sur le disque,

Mode binaire

La RecordLength clause dans la FileOpen fonction n’a aucun effet. FilePut écrit toutes les variables sur le disque de façon contiguë, c’est-à-dire sans remplissage entre les enregistrements.
Pour tout tableau autre qu’un tableau dans une structure, FilePut écrit uniquement les données. Aucun descripteur n’est écrit.
FilePut écrit des chaînes de longueur variable qui ne sont pas des éléments de structures sans le descripteur de longueur de deux octets. Le nombre d’octets écrits est égal au nombre de caractères dans la chaîne. Par exemple, les instructions suivantes écrivent 11 octets dans le numéro de fichier 1 :
```
Dim hellow As String = "Hello World"
FilePut(1, hellow)
```
L’écriture dans un fichier à l’aide de la FilePut fonction nécessite un Write accès à partir de l’énumération FileIOPermissionAccess .

Voir aussi

S’applique à

FilePut(Int32, Decimal, Int64)

Source:: FileSystem.vb

Source:: FileSystem.vb

Source:: FileSystem.vb

public static void FilePut (int FileNumber, decimal Value, long RecordNumber = -1);

static member FilePut : int * decimal * int64 -> unit

Public Sub FilePut (FileNumber As Integer, Value As Decimal, Optional RecordNumber As Long = -1)

Paramètres

FileNumber: Int32

Obligatoire. N’importe quel numéro de fichier valide.

Value: Decimal

Obligatoire. Nom de variable valide contenant les données écrites sur le disque.

RecordNumber: Int64

Optionnel. Numéro de l'enregistrement (fichiers ouverts en mode Random) ou de l'octet (fichiers ouverts en mode Binary) par lequel l'écriture débute.

Exceptions

ArgumentException

RecordNumber< 1 et différent de -1.

IOException

Le mode de fichier n’est pas valide.

Exemples

Cet exemple utilise la FilePut fonction pour écrire des données dans un fichier. Cinq enregistrements de la structure Person sont écrits dans le fichier.

Structure Person
    Public ID As Integer
    Public Name As String
End Structure

Sub WriteData()
    Dim PatientRecord As Person
    Dim recordNumber As Integer
    '    Open file for random access.
    FileOpen(1, "C:\TESTFILE.txt", OpenMode.Binary)
    ' Loop 5 times.
    For recordNumber = 1 To 5
        ' Define ID.
        PatientRecord.ID = recordNumber
        ' Create a string.
        PatientRecord.Name = "Name " & recordNumber
        ' Write record to file.
        FilePut(1, PatientRecord)
    Next recordNumber
    FileClose(1)
End Sub

Remarques

FilePut est valide uniquement en Random mode et Binary .

Les données écrites avec FilePut sont généralement lues à partir d’un fichier à l’aide de FileGet.

Mode aléatoire

Pour les fichiers ouverts en Random mode, les règles suivantes s’appliquent :

Si la longueur des données en cours d’écriture est inférieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, FilePut écrit les enregistrements suivants sur les limites de longueur d’enregistrement. L’espace entre la fin d’un enregistrement et le début de l’enregistrement suivant est complété avec le contenu existant de la mémoire tampon de fichier. Étant donné que la quantité de données de remplissage ne peut pas être déterminée avec certitude, il est généralement judicieux d’avoir la longueur de l’enregistrement correspondant à la longueur des données en cours d’écriture. Si la longueur des données en cours d’écriture est supérieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, une exception est levée.
Si la variable en cours d’écriture est une chaîne, FilePut écrit un descripteur de deux octets qui contient la longueur de chaîne, puis écrit les données qui vont dans la variable. Par conséquent, la longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure d’au moins deux octets à la longueur réelle de la chaîne.
Si la variable en cours d’écriture est un objet qui contient un type numérique, FilePut écrit deux octets identifiant le VarType de l’objet, puis écrit la variable. Par exemple, lors de l’écriture d’un objet qui contient un entier, FilePut écrit six octets : deux octets qui identifient l’objet comme VarType(3) (Integer) et quatre octets qui contiennent les données. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins deux octets au nombre d’octets requis pour stocker la variable.
Si la variable en cours d’écriture est un objet qui contient une chaîne, FilePut écrit un descripteur de deux octets identifiant le VarType(8) de l’objet, un descripteur de deux octets indiquant la longueur de la chaîne, puis écrit les données de chaîne. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins quatre octets à la longueur réelle de la chaîne. Si vous souhaitez placer une chaîne sans le descripteur, vous devez passer True au StringIsFixedLength paramètre, et la chaîne que vous lisez doit avoir la longueur correcte.
Si la variable en cours d’écriture est un tableau, vous avez le choix d’écrire ou non un descripteur pour la taille et les dimensions du tableau. Visual Basic 6.0 et les versions antérieures écrivent le descripteur de fichier pour un tableau dynamique, mais pas pour un tableau de taille fixe. Par défaut, Visual Basic 2005 n’écrit pas le descripteur. Pour écrire le descripteur, définissez le paramètre sur ArrayIsDynamicTrue. Lors de l’écriture du tableau, vous devez correspondre à la façon dont le tableau sera lu ; s’il est lu avec le descripteur, vous devez écrire le descripteur. Le descripteur spécifie le rang du tableau, la taille et les limites inférieures pour chaque classement. Sa longueur est égale à 2 plus 8 fois le nombre de dimensions : (2 + 8 * NumberOfDimensions). La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la somme de tous les octets nécessaires pour écrire les données du tableau et le descripteur de tableau. Par exemple, la déclaration de tableau suivante nécessite 218 octets lorsque le tableau est écrit sur le disque.
```
Dim MyArray(4, 9) As Integer
```
Si la variable en cours d’écriture est un autre type de variable (pas une chaîne de longueur variable ou un objet), FilePut écrit uniquement les données de variable. La longueur de l’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la longueur des données en cours d’écriture.
FilePut écrit des éléments de structures comme si chacun d’eux était écrit individuellement, sauf qu’il n’y a pas de remplissage entre les éléments. L’attribut VBFixedString peut être appliqué aux champs de chaîne dans les structures pour indiquer la taille de la chaîne en cas d’écriture sur disque.

Notes

Les champs de chaîne qui ont plus d’octets que spécifiés par l’attribut VBFixedString sont tronqués lorsqu’ils sont écrits sur le disque,

Mode binaire

La RecordLength clause de la FileOpen fonction n’a aucun effet. FilePut écrit toutes les variables sur le disque de manière contiguë, c’est-à-dire sans remplissage entre les enregistrements.
Pour tout tableau autre qu’un tableau d’une structure, FilePut écrit uniquement les données. Aucun descripteur n’est écrit.
FilePut écrit des chaînes de longueur variable qui ne sont pas des éléments de structures sans le descripteur de longueur de deux octets. Le nombre d’octets écrits est égal au nombre de caractères dans la chaîne. Par exemple, les instructions suivantes écrivent 11 octets dans le numéro de fichier 1 :
```
Dim hellow As String = "Hello World"
FilePut(1, hellow)
```
L’écriture dans un fichier à l’aide de la FilePut fonction nécessite l’accès Write à partir de l’énumération FileIOPermissionAccess .

Voir aussi

S’applique à

FilePut(Int32, DateTime, Int64)

Source:: FileSystem.vb

Source:: FileSystem.vb

Source:: FileSystem.vb

public static void FilePut (int FileNumber, DateTime Value, long RecordNumber = -1);

static member FilePut : int * DateTime * int64 -> unit

Public Sub FilePut (FileNumber As Integer, Value As DateTime, Optional RecordNumber As Long = -1)

Paramètres

FileNumber: Int32

Obligatoire. N’importe quel numéro de fichier valide.

Value: DateTime

Obligatoire. Nom de variable valide contenant les données écrites sur le disque.

RecordNumber: Int64

Optionnel. Numéro de l'enregistrement (fichiers ouverts en mode Random) ou de l'octet (fichiers ouverts en mode Binary) par lequel l'écriture débute.

Exceptions

ArgumentException

RecordNumber< 1 et différent de -1.

IOException

Le mode de fichier n’est pas valide.

Exemples

Cet exemple utilise la FilePut fonction pour écrire des données dans un fichier. Cinq enregistrements de la structure Person sont écrits dans le fichier.

Structure Person
    Public ID As Integer
    Public Name As String
End Structure

Sub WriteData()
    Dim PatientRecord As Person
    Dim recordNumber As Integer
    '    Open file for random access.
    FileOpen(1, "C:\TESTFILE.txt", OpenMode.Binary)
    ' Loop 5 times.
    For recordNumber = 1 To 5
        ' Define ID.
        PatientRecord.ID = recordNumber
        ' Create a string.
        PatientRecord.Name = "Name " & recordNumber
        ' Write record to file.
        FilePut(1, PatientRecord)
    Next recordNumber
    FileClose(1)
End Sub

Remarques

FilePut est valide uniquement en Random mode et Binary .

Les données écrites avec FilePut sont généralement lues à partir d’un fichier à l’aide de FileGet.

Mode aléatoire

Pour les fichiers ouverts en Random mode, les règles suivantes s’appliquent :

Si la longueur des données en cours d’écriture est inférieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, FilePut écrit les enregistrements suivants sur les limites de longueur d’enregistrement. L’espace entre la fin d’un enregistrement et le début de l’enregistrement suivant est complété avec le contenu existant de la mémoire tampon de fichier. Étant donné que la quantité de données de remplissage ne peut pas être déterminée avec certitude, il est généralement judicieux d’avoir la longueur de l’enregistrement correspondant à la longueur des données en cours d’écriture. Si la longueur des données en cours d’écriture est supérieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, une exception est levée.
Si la variable en cours d’écriture est une chaîne, FilePut écrit un descripteur de deux octets qui contient la longueur de chaîne, puis écrit les données qui vont dans la variable. Par conséquent, la longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure d’au moins deux octets à la longueur réelle de la chaîne.
Si la variable en cours d’écriture est un objet qui contient un type numérique, FilePut écrit deux octets identifiant le VarType de l’objet, puis écrit la variable. Par exemple, lors de l’écriture d’un objet qui contient un entier, FilePut écrit six octets : deux octets qui identifient l’objet comme VarType(3) (Integer) et quatre octets qui contiennent les données. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins deux octets au nombre d’octets requis pour stocker la variable.
Si la variable en cours d’écriture est un objet qui contient une chaîne, FilePut écrit un descripteur de deux octets identifiant le VarType(8) de l’objet, un descripteur de deux octets indiquant la longueur de la chaîne, puis écrit les données de chaîne. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins quatre octets à la longueur réelle de la chaîne. Si vous souhaitez placer une chaîne sans le descripteur, vous devez passer True au StringIsFixedLength paramètre, et la chaîne que vous lisez doit avoir la longueur correcte.
Si la variable en cours d’écriture est un tableau, vous avez le choix d’écrire ou non un descripteur pour la taille et les dimensions du tableau. Visual Basic 6.0 et les versions antérieures écrivent le descripteur de fichier pour un tableau dynamique, mais pas pour un tableau de taille fixe. Par défaut, Visual Basic 2005 n’écrit pas le descripteur. Pour écrire le descripteur, définissez le paramètre sur ArrayIsDynamicTrue. Lors de l’écriture du tableau, vous devez correspondre à la façon dont le tableau sera lu ; s’il est lu avec le descripteur, vous devez écrire le descripteur. Le descripteur spécifie le rang du tableau, la taille et les limites inférieures pour chaque classement. Sa longueur est égale à 2 plus 8 fois le nombre de dimensions : (2 + 8 * NumberOfDimensions). La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la somme de tous les octets nécessaires pour écrire les données du tableau et le descripteur de tableau. Par exemple, la déclaration de tableau suivante nécessite 218 octets lorsque le tableau est écrit sur le disque.
```
Dim MyArray(4, 9) As Integer
```
Si la variable en cours d’écriture est un autre type de variable (pas une chaîne de longueur variable ou un objet), FilePut écrit uniquement les données de variable. La longueur de l’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la longueur des données en cours d’écriture.
FilePut écrit des éléments de structures comme si chacun d’eux était écrit individuellement, sauf qu’il n’y a pas de remplissage entre les éléments. L’attribut VBFixedString peut être appliqué aux champs de chaîne dans les structures pour indiquer la taille de la chaîne en cas d’écriture sur disque.

Notes

Les champs de chaîne qui ont plus d’octets que spécifiés par l’attribut VBFixedString sont tronqués lorsqu’ils sont écrits sur le disque,

Mode binaire

La RecordLength clause de la FileOpen fonction n’a aucun effet. FilePut écrit toutes les variables sur le disque de manière contiguë, c’est-à-dire sans remplissage entre les enregistrements.
Pour tout tableau autre qu’un tableau d’une structure, FilePut écrit uniquement les données. Aucun descripteur n’est écrit.
FilePut écrit des chaînes de longueur variable qui ne sont pas des éléments de structures sans le descripteur de longueur de deux octets. Le nombre d’octets écrits est égal au nombre de caractères dans la chaîne. Par exemple, les instructions suivantes écrivent 11 octets dans le numéro de fichier 1 :
```
Dim hellow As String = "Hello World"
FilePut(1, hellow)
```
L’écriture dans un fichier à l’aide de la FilePut fonction nécessite l’accès Write à partir de l’énumération FileIOPermissionAccess .

Voir aussi

S’applique à

FilePut(Int32, Char, Int64)

Source:: FileSystem.vb

Source:: FileSystem.vb

Source:: FileSystem.vb

public static void FilePut (int FileNumber, char Value, long RecordNumber = -1);

static member FilePut : int * char * int64 -> unit

Public Sub FilePut (FileNumber As Integer, Value As Char, Optional RecordNumber As Long = -1)

Paramètres

FileNumber: Int32

Obligatoire. N’importe quel numéro de fichier valide.

Value: Char

Obligatoire. Nom de variable valide contenant les données écrites sur le disque.

RecordNumber: Int64

Optionnel. Numéro de l'enregistrement (fichiers ouverts en mode Random) ou de l'octet (fichiers ouverts en mode Binary) par lequel l'écriture débute.

Exceptions

ArgumentException

RecordNumber< 1 et différent de -1.

IOException

Le mode de fichier n’est pas valide.

Exemples

Cet exemple utilise la FilePut fonction pour écrire des données dans un fichier. Cinq enregistrements de la structure Person sont écrits dans le fichier.

Structure Person
    Public ID As Integer
    Public Name As String
End Structure

Sub WriteData()
    Dim PatientRecord As Person
    Dim recordNumber As Integer
    '    Open file for random access.
    FileOpen(1, "C:\TESTFILE.txt", OpenMode.Binary)
    ' Loop 5 times.
    For recordNumber = 1 To 5
        ' Define ID.
        PatientRecord.ID = recordNumber
        ' Create a string.
        PatientRecord.Name = "Name " & recordNumber
        ' Write record to file.
        FilePut(1, PatientRecord)
    Next recordNumber
    FileClose(1)
End Sub

Remarques

FilePut est valide uniquement en Random mode et Binary .

Les données écrites avec FilePut sont généralement lues à partir d’un fichier à l’aide de FileGet.

Mode aléatoire

Pour les fichiers ouverts en Random mode, les règles suivantes s’appliquent :

Si la longueur des données en cours d’écriture est inférieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, FilePut écrit les enregistrements suivants sur les limites de longueur d’enregistrement. L’espace entre la fin d’un enregistrement et le début de l’enregistrement suivant est complété avec le contenu existant de la mémoire tampon de fichier. Étant donné que la quantité de données de remplissage ne peut pas être déterminée avec certitude, il est généralement judicieux d’avoir la longueur de l’enregistrement correspondant à la longueur des données en cours d’écriture. Si la longueur des données en cours d’écriture est supérieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, une exception est levée.
Si la variable en cours d’écriture est une chaîne, FilePut écrit un descripteur de deux octets qui contient la longueur de chaîne, puis écrit les données qui vont dans la variable. Par conséquent, la longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure d’au moins deux octets à la longueur réelle de la chaîne.
Si la variable en cours d’écriture est un objet qui contient un type numérique, FilePut écrit deux octets identifiant le VarType de l’objet, puis écrit la variable. Par exemple, lors de l’écriture d’un objet qui contient un entier, FilePut écrit six octets : deux octets qui identifient l’objet comme VarType(3) (Integer) et quatre octets qui contiennent les données. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins deux octets au nombre d’octets requis pour stocker la variable.
Si la variable en cours d’écriture est un objet qui contient une chaîne, FilePut écrit un descripteur de deux octets identifiant le VarType(8) de l’objet, un descripteur de deux octets indiquant la longueur de la chaîne, puis écrit les données de chaîne. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins quatre octets à la longueur réelle de la chaîne. Si vous souhaitez placer une chaîne sans le descripteur, vous devez passer True au StringIsFixedLength paramètre, et la chaîne que vous lisez doit avoir la longueur correcte.
Si la variable en cours d’écriture est un tableau, vous avez le choix d’écrire ou non un descripteur pour la taille et les dimensions du tableau. Visual Basic 6.0 et les versions antérieures écrivent le descripteur de fichier pour un tableau dynamique, mais pas pour un tableau de taille fixe. Par défaut, Visual Basic 2005 n’écrit pas le descripteur. Pour écrire le descripteur, définissez le paramètre sur ArrayIsDynamicTrue. Lors de l’écriture du tableau, vous devez correspondre à la façon dont le tableau sera lu ; s’il est lu avec le descripteur, vous devez écrire le descripteur. Le descripteur spécifie le rang du tableau, la taille et les limites inférieures pour chaque classement. Sa longueur est égale à 2 plus 8 fois le nombre de dimensions : (2 + 8 * NumberOfDimensions). La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la somme de tous les octets nécessaires pour écrire les données du tableau et le descripteur de tableau. Par exemple, la déclaration de tableau suivante nécessite 218 octets lorsque le tableau est écrit sur le disque.
```
Dim MyArray(4, 9) As Integer
```
Si la variable en cours d’écriture est un autre type de variable (pas une chaîne de longueur variable ou un objet), FilePut écrit uniquement les données de variable. La longueur de l’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la longueur des données en cours d’écriture.
FilePut écrit des éléments de structures comme si chacun d’eux était écrit individuellement, sauf qu’il n’y a pas de remplissage entre les éléments. L’attribut VBFixedString peut être appliqué aux champs de chaîne dans les structures pour indiquer la taille de la chaîne en cas d’écriture sur disque.

Notes

Les champs de chaîne qui ont plus d’octets que spécifiés par l’attribut VBFixedString sont tronqués lorsqu’ils sont écrits sur le disque,

Mode binaire

La RecordLength clause de la FileOpen fonction n’a aucun effet. FilePut écrit toutes les variables sur le disque de manière contiguë, c’est-à-dire sans remplissage entre les enregistrements.
Pour tout tableau autre qu’un tableau d’une structure, FilePut écrit uniquement les données. Aucun descripteur n’est écrit.
FilePut écrit des chaînes de longueur variable qui ne sont pas des éléments de structures sans le descripteur de longueur de deux octets. Le nombre d’octets écrits est égal au nombre de caractères dans la chaîne. Par exemple, les instructions suivantes écrivent 11 octets dans le numéro de fichier 1 :
```
Dim hellow As String = "Hello World"
FilePut(1, hellow)
```
L’écriture dans un fichier à l’aide de la FilePut fonction nécessite l’accès Write à partir de l’énumération FileIOPermissionAccess .

Voir aussi

S’applique à

FilePut(Int32, Byte, Int64)

Source:: FileSystem.vb

Source:: FileSystem.vb

Source:: FileSystem.vb

public static void FilePut (int FileNumber, byte Value, long RecordNumber = -1);

static member FilePut : int * byte * int64 -> unit

Public Sub FilePut (FileNumber As Integer, Value As Byte, Optional RecordNumber As Long = -1)

Paramètres

FileNumber: Int32

Obligatoire. N’importe quel numéro de fichier valide.

Value: Byte

Obligatoire. Nom de variable valide contenant les données écrites sur le disque.

RecordNumber: Int64

Optionnel. Numéro de l'enregistrement (fichiers ouverts en mode Random) ou de l'octet (fichiers ouverts en mode Binary) par lequel l'écriture débute.

Exceptions

ArgumentException

RecordNumber< 1 et différent de -1.

IOException

Le mode de fichier n’est pas valide.

Exemples

Cet exemple utilise la FilePut fonction pour écrire des données dans un fichier. Cinq enregistrements de la structure Person sont écrits dans le fichier.

Structure Person
    Public ID As Integer
    Public Name As String
End Structure

Sub WriteData()
    Dim PatientRecord As Person
    Dim recordNumber As Integer
    '    Open file for random access.
    FileOpen(1, "C:\TESTFILE.txt", OpenMode.Binary)
    ' Loop 5 times.
    For recordNumber = 1 To 5
        ' Define ID.
        PatientRecord.ID = recordNumber
        ' Create a string.
        PatientRecord.Name = "Name " & recordNumber
        ' Write record to file.
        FilePut(1, PatientRecord)
    Next recordNumber
    FileClose(1)
End Sub

Remarques

FilePut est valide uniquement en Random mode et Binary .

Les données écrites avec FilePut sont généralement lues à partir d’un fichier à l’aide de FileGet.

Mode aléatoire

Pour les fichiers ouverts en Random mode, les règles suivantes s’appliquent :

Si la longueur des données en cours d’écriture est inférieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, FilePut écrit les enregistrements suivants sur les limites de longueur d’enregistrement. L’espace entre la fin d’un enregistrement et le début de l’enregistrement suivant est complété avec le contenu existant de la mémoire tampon de fichier. Étant donné que la quantité de données de remplissage ne peut pas être déterminée avec certitude, il est généralement judicieux d’avoir la longueur de l’enregistrement correspondant à la longueur des données en cours d’écriture. Si la longueur des données en cours d’écriture est supérieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, une exception est levée.
Si la variable en cours d’écriture est une chaîne, FilePut écrit un descripteur de deux octets qui contient la longueur de chaîne, puis écrit les données qui vont dans la variable. Par conséquent, la longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure d’au moins deux octets à la longueur réelle de la chaîne.
Si la variable en cours d’écriture est un objet qui contient un type numérique, FilePut écrit deux octets identifiant le VarType de l’objet, puis écrit la variable. Par exemple, lors de l’écriture d’un objet qui contient un entier, FilePut écrit six octets : deux octets qui identifient l’objet sous la forme VarType(3) (Integer) et quatre octets qui contiennent les données. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins deux octets au nombre d’octets requis pour stocker la variable.
Si la variable en cours d’écriture est un objet qui contient une chaîne, FilePut écrit un descripteur de deux octets identifiant le VarType(8) de l’objet, un descripteur de deux octets indiquant la longueur de la chaîne, puis écrit les données de chaîne. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins quatre octets à la longueur réelle de la chaîne. Si vous souhaitez placer une chaîne sans le descripteur, vous devez passer True au StringIsFixedLength paramètre , et la chaîne que vous lisez doit avoir la longueur correcte.
Si la variable en cours d’écriture est un tableau, vous avez le choix d’écrire ou non un descripteur pour la taille et les dimensions du tableau. Visual Basic 6.0 et les versions antérieures écrivent le descripteur de fichier pour un tableau dynamique, mais pas pour un tableau de taille fixe. Par défaut, Visual Basic 2005 n’écrit pas le descripteur. Pour écrire le descripteur, définissez le paramètre sur ArrayIsDynamicTrue. Lors de l’écriture du tableau, vous devez correspondre à la façon dont le tableau sera lu ; s’il est lu avec le descripteur, vous devez écrire le descripteur. Le descripteur spécifie le rang du tableau, la taille et les limites inférieures pour chaque classement. Sa longueur est égale à 2 plus 8 fois le nombre de dimensions : (2 + 8 * NumberOfDimensions). La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la somme de tous les octets requis pour écrire les données du tableau et le descripteur de tableau. Par exemple, la déclaration de tableau suivante nécessite 218 octets lorsque le tableau est écrit sur le disque.
```
Dim MyArray(4, 9) As Integer
```
Si la variable en cours d’écriture est un autre type de variable (et non une chaîne de longueur variable ou un objet), FilePut écrit uniquement les données de la variable. La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la longueur des données en cours d’écriture.
FilePut écrit des éléments de structures comme si chacun d’eux était écrit individuellement, sauf qu’il n’y a pas de remplissage entre les éléments. L’attribut VBFixedString peut être appliqué aux champs de chaîne dans les structures pour indiquer la taille de la chaîne lors de l’écriture sur disque.

Notes

Les champs de chaîne qui ont plus d’octets que spécifié par l’attribut VBFixedString sont tronqués lorsqu’ils sont écrits sur le disque,

Mode binaire

La RecordLength clause dans la FileOpen fonction n’a aucun effet. FilePut écrit toutes les variables sur le disque de façon contiguë, c’est-à-dire sans remplissage entre les enregistrements.
Pour tout tableau autre qu’un tableau dans une structure, FilePut écrit uniquement les données. Aucun descripteur n’est écrit.
FilePut écrit des chaînes de longueur variable qui ne sont pas des éléments de structures sans le descripteur de longueur de deux octets. Le nombre d’octets écrits est égal au nombre de caractères dans la chaîne. Par exemple, les instructions suivantes écrivent 11 octets dans le numéro de fichier 1 :
```
Dim hellow As String = "Hello World"
FilePut(1, hellow)
```
L’écriture dans un fichier à l’aide de la FilePut fonction nécessite un Write accès à partir de l’énumération FileIOPermissionAccess .

Voir aussi

S’applique à

FilePut(Int32, Boolean, Int64)

Source:: FileSystem.vb

Source:: FileSystem.vb

Source:: FileSystem.vb

public static void FilePut (int FileNumber, bool Value, long RecordNumber = -1);

static member FilePut : int * bool * int64 -> unit

Public Sub FilePut (FileNumber As Integer, Value As Boolean, Optional RecordNumber As Long = -1)

Paramètres

FileNumber: Int32

Obligatoire. N’importe quel numéro de fichier valide.

Value: Boolean

Obligatoire. Nom de variable valide contenant les données écrites sur le disque.

RecordNumber: Int64

Optionnel. Numéro de l'enregistrement (fichiers ouverts en mode Random) ou de l'octet (fichiers ouverts en mode Binary) par lequel l'écriture débute.

Exceptions

ArgumentException

RecordNumber< 1 et différent de -1.

IOException

Le mode de fichier n’est pas valide.

Exemples

Cet exemple utilise la FilePut fonction pour écrire des données dans un fichier. Cinq enregistrements de la structure Person sont écrits dans le fichier.

Structure Person
    Public ID As Integer
    Public Name As String
End Structure

Sub WriteData()
    Dim PatientRecord As Person
    Dim recordNumber As Integer
    '    Open file for random access.
    FileOpen(1, "C:\TESTFILE.txt", OpenMode.Binary)
    ' Loop 5 times.
    For recordNumber = 1 To 5
        ' Define ID.
        PatientRecord.ID = recordNumber
        ' Create a string.
        PatientRecord.Name = "Name " & recordNumber
        ' Write record to file.
        FilePut(1, PatientRecord)
    Next recordNumber
    FileClose(1)
End Sub

Remarques

FilePut est valide uniquement en Random mode et Binary .

Les données écrites avec FilePut sont généralement lues à partir d’un fichier à l’aide de FileGet.

Mode aléatoire

Pour les fichiers ouverts en Random mode, les règles suivantes s’appliquent :

Si la longueur des données en cours d’écriture est inférieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, FilePut écrit les enregistrements suivants sur les limites de longueur d’enregistrement. L’espace entre la fin d’un enregistrement et le début de l’enregistrement suivant est rempli avec le contenu existant de la mémoire tampon de fichier. Étant donné que la quantité de données de remplissage ne peut pas être déterminée avec certitude, il est généralement judicieux de faire en sorte que la longueur de l’enregistrement corresponde à la longueur des données en cours d’écriture. Si la longueur des données en cours d’écriture est supérieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, une exception est levée.
Si la variable en cours d’écriture est une chaîne, FilePut écrit un descripteur de deux octets qui contient la longueur de chaîne, puis écrit les données qui vont dans la variable. Par conséquent, la longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure d’au moins deux octets à la longueur réelle de la chaîne.
Si la variable en cours d’écriture est un objet qui contient un type numérique, FilePut écrit deux octets identifiant le VarType de l’objet, puis écrit la variable. Par exemple, lors de l’écriture d’un objet qui contient un entier, FilePut écrit six octets : deux octets qui identifient l’objet sous la forme VarType(3) (Integer) et quatre octets qui contiennent les données. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins deux octets au nombre d’octets requis pour stocker la variable.
Si la variable en cours d’écriture est un objet qui contient une chaîne, FilePut écrit un descripteur de deux octets identifiant le VarType(8) de l’objet, un descripteur de deux octets indiquant la longueur de la chaîne, puis écrit les données de chaîne. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins quatre octets à la longueur réelle de la chaîne. Si vous souhaitez placer une chaîne sans le descripteur, vous devez passer True au StringIsFixedLength paramètre , et la chaîne que vous lisez doit avoir la longueur correcte.
Si la variable en cours d’écriture est un tableau, vous avez le choix d’écrire ou non un descripteur pour la taille et les dimensions du tableau. Visual Basic 6.0 et les versions antérieures écrivent le descripteur de fichier pour un tableau dynamique, mais pas pour un tableau de taille fixe. Par défaut, Visual Basic 2005 n’écrit pas le descripteur. Pour écrire le descripteur, définissez le paramètre sur ArrayIsDynamicTrue. Lors de l’écriture du tableau, vous devez correspondre à la façon dont le tableau sera lu ; s’il est lu avec le descripteur, vous devez écrire le descripteur. Le descripteur spécifie le rang du tableau, la taille et les limites inférieures pour chaque classement. Sa longueur est égale à 2 plus 8 fois le nombre de dimensions : (2 + 8 * NumberOfDimensions). La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la somme de tous les octets requis pour écrire les données du tableau et le descripteur de tableau. Par exemple, la déclaration de tableau suivante nécessite 218 octets lorsque le tableau est écrit sur le disque.
```
Dim MyArray(4, 9) As Integer
```
Si la variable en cours d’écriture est un autre type de variable (et non une chaîne de longueur variable ou un objet), FilePut écrit uniquement les données de la variable. La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la longueur des données en cours d’écriture.
FilePut écrit des éléments de structures comme si chacun d’eux était écrit individuellement, sauf qu’il n’y a pas de remplissage entre les éléments. L’attribut VBFixedString peut être appliqué aux champs de chaîne dans les structures pour indiquer la taille de la chaîne lors de l’écriture sur disque.

Notes

Les champs de chaîne qui ont plus d’octets que spécifié par l’attribut VBFixedString sont tronqués lorsqu’ils sont écrits sur le disque,

Mode binaire

La RecordLength clause dans la FileOpen fonction n’a aucun effet. FilePut écrit toutes les variables sur le disque de façon contiguë, c’est-à-dire sans remplissage entre les enregistrements.
Pour tout tableau autre qu’un tableau dans une structure, FilePut écrit uniquement les données. Aucun descripteur n’est écrit.
FilePut écrit des chaînes de longueur variable qui ne sont pas des éléments de structures sans le descripteur de longueur de deux octets. Le nombre d’octets écrits est égal au nombre de caractères dans la chaîne. Par exemple, les instructions suivantes écrivent 11 octets dans le numéro de fichier 1 :
```
Dim hellow As String = "Hello World"
FilePut(1, hellow)
```
L’écriture dans un fichier à l’aide de la FilePut fonction nécessite un Write accès à partir de l’énumération FileIOPermissionAccess .

Voir aussi

S’applique à

FilePut(Int32, Int16, Int64)

Source:: FileSystem.vb

Source:: FileSystem.vb

Source:: FileSystem.vb

public static void FilePut (int FileNumber, short Value, long RecordNumber = -1);

static member FilePut : int * int16 * int64 -> unit

Public Sub FilePut (FileNumber As Integer, Value As Short, Optional RecordNumber As Long = -1)

Paramètres

FileNumber: Int32

Obligatoire. N’importe quel numéro de fichier valide.

Value: Int16

Obligatoire. Nom de variable valide contenant les données écrites sur le disque.

RecordNumber: Int64

Optionnel. Numéro de l'enregistrement (fichiers ouverts en mode Random) ou de l'octet (fichiers ouverts en mode Binary) par lequel l'écriture débute.

Exceptions

ArgumentException

RecordNumber< 1 et différent de -1.

IOException

Le mode de fichier n’est pas valide.

Exemples

Cet exemple utilise la FilePut fonction pour écrire des données dans un fichier. Cinq enregistrements de la structure Person sont écrits dans le fichier.

Structure Person
    Public ID As Integer
    Public Name As String
End Structure

Sub WriteData()
    Dim PatientRecord As Person
    Dim recordNumber As Integer
    '    Open file for random access.
    FileOpen(1, "C:\TESTFILE.txt", OpenMode.Binary)
    ' Loop 5 times.
    For recordNumber = 1 To 5
        ' Define ID.
        PatientRecord.ID = recordNumber
        ' Create a string.
        PatientRecord.Name = "Name " & recordNumber
        ' Write record to file.
        FilePut(1, PatientRecord)
    Next recordNumber
    FileClose(1)
End Sub

Remarques

FilePut est valide uniquement en Random mode et Binary .

Les données écrites avec FilePut sont généralement lues à partir d’un fichier à l’aide de FileGet.

Mode aléatoire

Pour les fichiers ouverts en Random mode, les règles suivantes s’appliquent :

Si la longueur des données en cours d’écriture est inférieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, FilePut écrit les enregistrements suivants sur les limites de longueur d’enregistrement. L’espace entre la fin d’un enregistrement et le début de l’enregistrement suivant est rempli avec le contenu existant de la mémoire tampon de fichier. Étant donné que la quantité de données de remplissage ne peut pas être déterminée avec certitude, il est généralement judicieux de faire en sorte que la longueur de l’enregistrement corresponde à la longueur des données en cours d’écriture. Si la longueur des données en cours d’écriture est supérieure à la longueur spécifiée dans la RecordLength clause de la FileOpen fonction, une exception est levée.
Si la variable en cours d’écriture est une chaîne, FilePut écrit un descripteur de deux octets qui contient la longueur de chaîne, puis écrit les données qui vont dans la variable. Par conséquent, la longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure d’au moins deux octets à la longueur réelle de la chaîne.
Si la variable en cours d’écriture est un objet qui contient un type numérique, FilePut écrit deux octets identifiant le VarType de l’objet, puis écrit la variable. Par exemple, lors de l’écriture d’un objet qui contient un entier, FilePut écrit six octets : deux octets qui identifient l’objet sous la forme VarType(3) (Integer) et quatre octets qui contiennent les données. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins deux octets au nombre d’octets requis pour stocker la variable.
Si la variable en cours d’écriture est un objet qui contient une chaîne, FilePut écrit un descripteur de deux octets identifiant leVarType(8) de l’objet, un descripteur de deux octets indiquant la longueur de la chaîne, puis écrit les données de chaîne. La longueur d’enregistrement spécifiée par le RecordLength paramètre dans la FileOpen fonction doit être supérieure d’au moins quatre octets à la longueur réelle de la chaîne. Si vous souhaitez placer une chaîne sans le descripteur, vous devez passer True au StringIsFixedLength paramètre , et la chaîne que vous lisez doit avoir la longueur correcte.
Si la variable en cours d’écriture est un tableau, vous avez le choix d’écrire ou non un descripteur pour la taille et les dimensions du tableau. Visual Basic 6.0 et les versions antérieures écrivent le descripteur de fichier pour un tableau dynamique, mais pas pour un tableau de taille fixe. Par défaut, Visual Basic 2005 n’écrit pas le descripteur. Pour écrire le descripteur, définissez le paramètre sur ArrayIsDynamicTrue. Lors de l’écriture du tableau, vous devez correspondre à la façon dont le tableau sera lu ; s’il est lu avec le descripteur, vous devez écrire le descripteur. Le descripteur spécifie le rang du tableau, la taille et les limites inférieures pour chaque classement. Sa longueur est égale à 2 plus 8 fois le nombre de dimensions : (2 + 8 * NumberOfDimensions). La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la somme de tous les octets requis pour écrire les données du tableau et le descripteur de tableau. Par exemple, la déclaration de tableau suivante nécessite 218 octets lorsque le tableau est écrit sur le disque.
```
Dim MyArray(4, 9) As Integer
```
Si la variable en cours d’écriture est un autre type de variable (et non une chaîne de longueur variable ou un objet), FilePut écrit uniquement les données de la variable. La longueur d’enregistrement spécifiée par la RecordLength clause dans la FileOpen fonction doit être supérieure ou égale à la longueur des données en cours d’écriture.
FilePut écrit des éléments de structures comme si chacun d’eux était écrit individuellement, sauf qu’il n’y a pas de remplissage entre les éléments. L’attribut VBFixedString peut être appliqué aux champs de chaîne dans les structures pour indiquer la taille de la chaîne lors de l’écriture sur disque.

Notes

Les champs de chaîne qui ont plus d’octets que spécifié par l’attribut VBFixedString sont tronqués lorsqu’ils sont écrits sur le disque,

Mode binaire

La RecordLength clause dans la FileOpen fonction n’a aucun effet. FilePut écrit toutes les variables sur le disque de façon contiguë, c’est-à-dire sans remplissage entre les enregistrements.
Pour tout tableau autre qu’un tableau dans une structure, FilePut écrit uniquement les données. Aucun descripteur n’est écrit.
FilePut écrit des chaînes de longueur variable qui ne sont pas des éléments de structures sans le descripteur de longueur de deux octets. Le nombre d’octets écrits est égal au nombre de caractères dans la chaîne. Par exemple, les instructions suivantes écrivent 11 octets dans le numéro de fichier 1 :
```
Dim hellow As String = "Hello World"
FilePut(1, hellow)
```
L’écriture dans un fichier à l’aide de la FilePut fonction nécessite un Write accès à partir de l’énumération FileIOPermissionAccess .

Voir aussi

S’applique à