Pour gérer les flux de fichiers et les opérations d'E / S en C #, vous devez ma?triser les classes de base et les modes tels que FileStream, StreamReader, les E / S asynchrones et le traitement du chemin. 1. Utilisez FileStream pour effectuer des opérations de fichiers sous-jacentes, prendre en charge la synchronisation / contr?le asynchrone et le contr?le du mode d'accès, et utilisez pour assurer la libération des ressources et faire attention aux paramètres de fileMode et de fichier; 2. StreamReader et Streamwriter fournissent une encapsulation de lecture de texte et d'écriture, qui est plus simple et plus facile à utiliser, peut spécifier des méthodes de codage et peut simplifier les opérations uniques par file.readallText () et d'autres simplifier les opérations uniques; 3. 4. Lors du traitement des chemins, utilisez les méthodes de chemin de chemin et existe () pour assurer l'exactitude du chemin et la prévention des exceptions, et construire une structure de répertoire avec répertoire.CreateDirectory.

Gestion des opérations de streaming de fichiers et d'E / S en C # est une partie très basique mais sujet aux erreurs du développement. Que ce soit la lecture et la rédaction de fichiers texte, la manipulation de données binaires ou l'exécution d'opérations asynchrones, vous devez avoir une certaine compréhension de FileStream, StreamReader et d'autres classes connexes.

1. Utilisez FileStream pour effectuer des opérations de fichiers sous-jacentes

FileStream est l'une des classes les plus couramment utilisées en C # pour interagir directement avec le système de fichiers. Il prend en charge les opérations synchrones et asynchrones et peut contr?ler le mode d'accès des fichiers (tels que en lecture seule, écriture, ajouter) et des méthodes de partage.

Utilisation de base:

 Utilisation (var fs = new FileStream ("Exemple.txt", fileMode.OpenorCreate, FileAccess.Write))
{
    Byte [] info = new UTF8Encoding (true) .getBytes ("Bonjour, fichier!");
    fs.write (info, 0, info.length);
}

Notes:

• Utilisez toujours l'instruction using pour vous assurer que le flux est libéré correctement.
• Faites attention aux différentes options de FileMode , telles que OpenOrCreate , Append , etc.
• Si plusieurs threads ou processus peuvent accéder au fichier en même temps, envisagez de définir les paramètres FileShare appropriés.

2. Traitez rapidement le texte avec StreamReader et StreamWriter

Si vous n'avez besoin que de lire et d'écrire du contenu texte, vous pouvez utiliser des classes d'encapsulation de niveau supérieur: StreamReader et StreamWriter , qui sont construites sur FileStream , mais sont plus concises à utiliser.

Exemple de lecture du fichier entier:

 Utilisation (var Reader = new StreamReader ("Example.txt"))
{
    ligne de cha?ne;
    while ((line = reader.readline ())! = null)
    {
        Console.writeline (ligne);
    }
}

Exemples d'écriture de texte:

 Utilisation (var writer = new StreamWriter ("output.txt"))
{
    writer.writeline ("Ceci est une ligne de texte.");
}

Conseils:

• La méthode d'encodage peut être spécifiée via le constructeur, tel que new StreamWriter("file.txt", Encoding.UTF8) .
• Si vous souhaitez simplement lire le fichier entier en même temps, vous pouvez utiliser File.ReadAllText() ou File.ReadAllLines() .

3. E / S asynchrone améliore la réactivité

Pour les fichiers volumineux ou les opérations de fichiers réseau, il est recommandé d'utiliser des méthodes asynchrones pour éviter de bloquer le thread principal. C # fournit un support async/await , ce qui rend le code efficace et facile à entretenir.

Exemple de lecture asynchrone:

 tache asynchrone privée ReadFileSync (chemin de cha?ne)
{
    Utilisation (var Reader = new StreamReader (chemin))
    {
        String Content = Await Reader.ReadToEndaSync ();
        Console.WriteLine (Contenu);
    }
}

Exemple d'écriture asynchrone:

 tache asynchrone privée writeFileSync (String Path, String Content)
{
    Utilisation (var écrivain = nouveau stream-rédacteur (chemin))
    {
        Await writer.writeasync (contenu);
    }
}

suggestion:

• Essayez d'utiliser des versions asynchrones dans des applications d'interface utilisateur ou des API Web pour améliorer l'expérience et le débit utilisateur.
• Ne mélangez pas les opérations synchrones et asynchrones pour éviter les problèmes de blocage.
• N'oubliez pas d'ajouter await lorsque vous appelez la méthode asynchrone.

4. Vérification du chemin du processus et de l'existence des fichiers

Dans les projets réels, il est souvent nécessaire de déterminer si le fichier existe ou construire le chemin du fichier correct. Bien que cette partie soit simple, elle est également très importante.

Les pratiques courantes comprennent:

• Vérifiez si le fichier existe:

   if (file.exists ("data.txt"))
  {
      // effectuer une action}

• Obtenez le chemin complet:

   String fullPath = path.getfullPath ("relative / path / file.txt");

• Fusion des fragments de chemin:

   String filepath = path.combine ("dossier", "sous-fichier", "file.txt");

  Note:

  • Le séparateur de chemin ne doit pas être codé en dur, utiliser Path.DirectorySeparatorChar ou Path.Combine .
  • Il est préférable de vérifier s'il existe avant le fonctionnement du fichier pour éviter de lancer des exceptions.
  • Vous pouvez créer une structure de répertoire en conjonction avec Directory.CreateDirectory() .

  ---

  Fondamentalement, ces opérations communes. En ma?trisant ces classes et modèles de base, vous pouvez gérer de manière flexible diverses exigences d'E / S de fichiers en C #.

  Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!