Page d'Accueil

Introduction au traitement de fichier

 

Vue d'ensemble du traitement de fichier et des définitions

 

Introduction

Dans la leçon 2, nous avons vu qu'une information utilisée dans une application était principalement représentée comme un groupe de bit. Jusqu'ici, si nous demandions une information à l'utilisateur, quand l'application est émulée, nous perdions toute l'information que l'utilisateur avait écrite. C'est parce qu'une telle information a été seulement temporairement stockée dans la mémoire à accès aléatoire (RAM). Dans certains cas, vous voudrez « garder » l'information que l'utilisateur a écrite ainsi vous pouvez rendre l'information disponible la prochaine fois que l'utilisateur ouvrira l'application. Dans quelques autres cas, si vous demandez une information à l'utilisateur ou la lui fournissez par transmission, vous pouvez vouloir que différentes personnes travaillant à partir de différents ordinateurs utilisent ou partagent les mêmes données. Dans ces derniers et d'autres scénarios, vous devez stocker l'information quelque part et la recouvrer si nécessaire. C'est la base du traitement de fichier.

fichiers

Un fichier est une série de bytes de données qui sont arrangées d'une façon particulière pour produire un document utilisable. Pour un stockage, un emplacement, et une gestion faciles, les bytes sont stockés sur un médium tel qu'un disque dur, un disque souple, un disque compact, ou n'importe quel type de support et de stockage valide. Quand ces bytes appartiennent à une entité simple mais commune et contiennent les valeurs qui sont stockées sur un médium, le groupe est désigné sous le nom de fichier.

Pour une plus grande gestion, les fichiers peuvent être stockés dans un objet parent appelé un répetoire ou un dossier. Puisqu'un fichier est une unité de stockage et qu'il stocke l'information, il a une taille, qui est le nombre de bits qu'il utilise pour stocker ses valeurs. Pour le contrôler, un fichier a un emplacement également appelé un chemin qui indique où et/ou comment le fichier peut être recouvré. En outre, pour une meilleure gestion, un fichier a des attributs (caractéristiques) qui indiquent ce qui peut être fait sur le fichier ou qui fournissent des informations spécifiques que le programmeur ou le logiciel d'exploitation peut utiliser en traitant le fichier .

Jets

Le traitement de fichier consite à créer, stocker, et/ou recouvrer le contenu d'un fichier d'un médium reconnaissable. Par exemple, il est utilisé pour sauvegarder les fichiers de traitement de texte dans un disque dur, pour stocker une présentation sur une disquette, ou pour ouvrir un fichier d'un CD-ROM. Un flot est la technique ou les moyens d'exécuter le traitement de fichiers. Afin de contrôler des fichiers stockés dans un ordinateur, chaque fichier doit pouvoir fournir les informations de base à son sujet. Ces informations de base sont indiquées quand le dossier est créé mais peuvent changer pendant la vie du fichier .

Pour créer un fichier, un utilisateur doit d'abord décider où il serait localisé : c'est une condition. Un fichier peut être localisé sur la racine de l'unité de disque. Alternativement, un fichier peut être placé à l'intérieur d'un dosier existant. Basé sur des considérations de sécurité, un utilisateur peut ne pas pouvoir créer un fichier n'importe où dans (fichiers système de) l'ordinateur. Une fois que l'utilisateur a décidé où le fichier résiderait, il y a divers moyens, (les utilisateurs sont formés pour les utiliser), de créer les fichiers. En créant un fichier, l'utilisateur doit lui donner un nom d'après les règles du logiciel d'exploitation combinées avec celles du système de fichiers. L'information la plus fondamentale qu'un fichier doit avoir est un nom.

Une fois que l'utilisateur a créé un fichier, que le fichier soit vide ou pas, le logiciel d'exploitation lui assigne les informations de base. Une fois qu'un fichier est créé, il peut être ouvert, mis à jour, modifié, renommé, etc.

Séquençage (streaming) prérequis

 

Introduction

Pour soutenir le traitement de fichier, .NET Framework fournit le namespace System.IO qui contient plusieurs différentes classes pour manipuler presque n'importe quel type d'opération  que vous pouvez avoir besoin d'effectuer sur le fichier. Par conséquent, pour exécuter le traitement de fichier, vous pouvez inclure le namespace System.IO dans votre projet.

La classe parent du traitement de fichier est Stream. Avec Stream, vous pouvez stocker des données dans un Stream ou vous pouvez recouvrer les données d'un Stream. Stream est une classe abstraite, qui signifie que vous ne pouvez pas l'utiliser pour déclarer une variable dans votre application. Comme classe abstraite, Stream est utilisé en tant que parent des classes qui mettent réellement en application les opérations nécessaires. Vous utiliserez habituellement une combinaison des classes pour effectuer une opération typique. Par exemple, quelques classes sont utilisées pour créer un objet Stream tandis que quelques autres sont utilisées pour écrire des données dans le Stream créé.

Étude pratiqueÉtude pratique : Présentation du streaming

  1. Commencez Microsoft Visual C# et créez une application de console appelée IceCream3
  2. Sauvegardez le projet, sur la barre d'outils standard, cliquez le bouton sauvegarder tout  Économiser tous
  3. Changez le nom de solution en VendingMachine3
  4. Acceptez le nom du projet comme IceCream3 et cliquez sauvegarder
  5. Pour créer une nouvelle classe, sur le menu principal, cliquez projet - > Ajouter la classe…
  6. Placez le nom IceScream et cliquez Ajouter
  7. Changez le fichier comme suit :
     
    using System;
    
    namespace IceCream3
    {
        delegate void Request();
    
        // This class is used to create and manage an ice scream
        // and to process an order
        public sealed class IceScream
        {
            // This is the base price of an ice scream
            // Optional values may be added to it
            public const decimal BasePrice = 1.55M;
    
            // These arrays are used to build the components 
            // of various ice screams
            // In C#, we can allocate an array's memory in 
            // the body of the class
            private string[] Flavor;
            private string[] Container;
            private string[] Ingredient;
    
            // Additional factor used to process an ice scream order
            private int Scoops;
            private decimal TotalPrice;
    
            // Variables that will hold the user's choice
            // These are declared "globally" so they can be 
            // shared among methods
            int ChoiceFlavor;
            int ChoiceContainer;
            int ChoiceIngredient;
    
            // This default constructor is the best place for 
            // us to initialize the array
            public IceScream()
            {
                Flavor = new string[10];
                Flavor[0] = "Vanilla";
                Flavor[1] = "Cream of Cocoa";
                Flavor[2] = "Chocolate Chip";
                Flavor[3] = "Organic Strawberry";
                Flavor[4] = "Butter Pecan";
                Flavor[5] = "Cherry Coke";
                Flavor[6] = "Chocolate Brownies";
                Flavor[7] = "Caramel Au Lait";
                Flavor[8] = "Chunky Butter";
                Flavor[9] = "Chocolate Cookie";
    
                Ingredient = new string[4];
                Ingredient[0] = "No Ingredient";
                Ingredient[1] = "Peanuts";
                Ingredient[2] = "M & M";
                Ingredient[3] = "Cookies";
    
                Container = new string[3];
                Container[0] = "Cone";
                Container[1] = "Cup";
                Container[2] = "Bowl";
            }
    
            // This method requests a flavor from the user and
            // returns the choice
            public void ChooseFlavor()
            {
                // Make sure the user selects a valid number 
                //that represents a flavor...
                do
                {
                    // In case the user types a symbol that 
                    // is not a number
                    try
                    {
                        Console.WriteLine("What type of flavor do you want?");
                        for (int i = 0; i < Flavor.Length; i++)
                            Console.WriteLine("{0} - {1}", i + 1, Flavor[i]);
                        Console.Write("Your Choice? ");
                        ChoiceFlavor = int.Parse(Console.ReadLine());
                    }
                    catch (FormatException)	// display an appropriate message
                    {
                        Console.WriteLine("You must enter a valid number " +
                                          "and no other character!");
                    }
    
                    // If the user typed an invalid number out of the 
                    // allowed range
                    // let him or her know and provide another chance
                    if (ChoiceFlavor < 1 || ChoiceFlavor > Flavor.Length)
                        Console.WriteLine("Invalid Choice - Try Again!\n");
                } while (ChoiceFlavor < 1 || ChoiceFlavor > Flavor.Length);
            }
    
            // This method allows the user to select a container
            public void ChooseContainer()
            {
                // Make sure the user selects a valid number that 
                // represents a container
                do
                {
                    // If the user types a symbol that is not a number
                    try
                    {
                        Console.WriteLine("What type of container do you want?");
                        for (int i = 0; i < Container.Length; i++)
                            Console.WriteLine("{0} - {1}", i + 1, Container[i]);
                        Console.Write("Your Choice? ");
                        ChoiceContainer = int.Parse(Console.ReadLine());
                    }
                    catch (FormatException)	// display an appropriate message
                    {
                        Console.WriteLine("You must enter a valid " +
                                          "number and no other character!");
                    }
    
                    // If the user typed an invalid number out of the 
                    // allowed range
                    // let him or her know and provide another chance
                    if ((ChoiceContainer < 1) ||
                        (ChoiceContainer > Container.Length))
                        Console.WriteLine("Invalid Choice - Try Again!");
                } while ((ChoiceContainer < 1) ||
                         (ChoiceContainer > Container.Length));
            }
    
            public void ChooseIngredient()
            {
                do
                {
                    try
                    {
                        Console.WriteLine("Do you want an ingredient or not");
                        for (int i = 0; i < Ingredient.Length; i++)
                            Console.WriteLine("{0} - {1}",
                                              i + 1,
                                              Ingredient[i]);
                        Console.Write("Your Choice? ");
                        ChoiceIngredient = int.Parse(Console.ReadLine());
                    }
                    catch (FormatException)
                    {
                        Console.WriteLine("You must enter a valid " +
                                          "number and no other character!");
                    }
    
                    if ((ChoiceIngredient < 1) ||
                        (ChoiceIngredient > Ingredient.Length))
                        Console.WriteLine("Invalid Choice - Try Again!");
                } while ((ChoiceIngredient < 1) ||
                         (ChoiceIngredient > Ingredient.Length));
            }
    
            public void SpecifyNumberOfScoops()
            {
                do
                {
                    try
                    {
                        Console.Write("How many scoops(1, 2, or 3)? ");
                        Scoops = int.Parse(Console.ReadLine());
                    }
                    catch (FormatException)
                    {
                        Console.WriteLine("You must enter a valid number " +
                                          "and no other character!");
                    }
    
                    if (Scoops < 1 || Scoops > 3)
                        Console.WriteLine("Invalid Choice - Try Again!");
                } while (Scoops < 1 || Scoops > 3);
            }
    
            // This method is used to process a customer order
            // It uses the values of the above methods
            public void ProcessAnOrder()
            {
                //			int ChoiceFlavor;
                //			int ChoiceContainer;
                //			int ChoiceIngredient;
                decimal PriceIngredient, PriceScoop;
    
                // Let the user know that this is a vending machine
                Console.WriteLine("=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=");
                Console.WriteLine("Ice Scream Vending Machine");
                Console.WriteLine("-----------------------------------");
    
                // Let the user select the components of the ice scream
                Request Get = new Request(ChooseFlavor);
                Get();
                Console.WriteLine("-----------------------------------");
                Get = new Request(ChooseContainer);
                Get();
                Console.WriteLine("-----------------------------------");
                Get = new Request(ChooseIngredient);
                Get();
                Console.WriteLine("-----------------------------------");
                Get = new Request(SpecifyNumberOfScoops);
                Get();
                Console.WriteLine("-----------------------------------");
    
                // If the user selects an ingredient instead of "No Ingredient",
                // add $0.50 to the order
                if ((ChoiceIngredient == 2) ||
                    (ChoiceIngredient == 3) ||
                    (ChoiceIngredient == 4))
                    PriceIngredient = 0.50M;
                else
                    PriceIngredient = 0.00M;
    
                // Instead of multiplying a number scoops to a value,
                // We will use an incremental value depending on 
                // the number of scoops
                if (Scoops == 1)
                    PriceScoop = 0.65M;
                else if (Scoops == 2)
                    PriceScoop = 1.05M;
                else
                    PriceScoop = 1.55M;
    
                // Calculate the total price of the ice scream
                TotalPrice = BasePrice + PriceScoop + PriceIngredient;
    
                // Create the ice scream...
    
                // And display a receipt to the user
                DisplayReceipt();
            }
    
            // This method is used to display a receipt to the user
            public void DisplayReceipt()
            {
                Console.WriteLine("\n=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=");
                Console.WriteLine("Ice Scream Order");
                Console.WriteLine("-----------------------------------");
                Console.WriteLine("Flavor:      {0}",
                                  Flavor[ChoiceFlavor - 1]);
                Console.WriteLine("Container:   {0}",
                                  Container[ChoiceContainer - 1]);
                Console.WriteLine("Ingredient:  {0}",
                                  Ingredient[ChoiceIngredient - 1]);
                Console.WriteLine("Scoops:      {0}", Scoops);
                Console.WriteLine("Total Price: {0:C}", TotalPrice);
                Console.WriteLine("=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=\n");
            }
        }
    }
  8. Accédez au fichier Program.cs et changez le comme suit :
     
    using System;
    
    namespace IceCream3
    {
        class Program
        {
            static int Main(string[] args)
            {
                IceScream ic = new IceScream();
                Request process = new Request(ic.ProcessAnOrder);
    
                process();
                return 0;
            }
        }
    }
  9. Exécutez le projet et l'examiner. Voici un exemple :
     
    =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
    Ice Scream Vending Machine
    -----------------------------------
    What type of flavor do you want?
    1 - Vanilla
    2 - Cream of Cocoa
    3 - Chocolate Chip
    4 - Organic Strawberry
    5 - Butter Pecan
    6 - Cherry Coke
    7 - Chocolate Brownies
    8 - Caramel Au Lait
    9 - Chunky Butter
    10 - Chocolate Cookie
    Your Choice? 3
    -----------------------------------
    What type of container do you want?
    1 - Cone
    2 - Cup
    3 - Bowl
    Your Choice? 5
    Invalid Choice - Try Again!
    What type of container do you want?
    1 - Cone
    2 - Cup
    3 - Bowl
    Your Choice? 3
    -----------------------------------
    Do you want an ingredient or not
    1 - No Ingredient
    2 - Peanuts
    3 - M & M
    4 - Cookies
    Your Choice? 8
    Invalid Choice - Try Again!
    Do you want an ingredient or not
    1 - No Ingredient
    2 - Peanuts
    3 - M & M
    4 - Cookies
    Your Choice? 4
    -----------------------------------
    How many scoops(1, 2, or 3)? 3
    -----------------------------------
    
    =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
    Ice Scream Order
    -----------------------------------
    Flavor:      Chocolate Chip
    Container:   Bowl
    Ingredient:  Cookies
    Scoops:      3
    Total Price: $3.60
    =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
    
    Press any key to continue . . .
  10. Fermez la fenêtre DOS

Le nom d'un fichier

Avant d'exécuter le traitement de fichier, une de vos premières décisions consistera à indiquer le type d'opération que vous voulez que l'utilisateur effectue. Par exemple, l'utilisateur peut vouloir créer un nouveau fichier, ouvrir un fichier existant, ou effectuer une opération courante sur un fichier. Dans tout ou la plupart des cas, si vous créez un nouveau fichier ou manipulez un existant, vous devez indiquer le nom du fichier. Vous pouvez faire ceci en déclarant une variable string mais, car nous l'apprendrons plus tard, la plupart des classes utilisées pour créer un stream peuvent prendre un string qui représente le fichier .

Si vous créez un nouveau fichier, il y a certainement quelques règles que vous devez observer. Le nom d'un fichier suit les directives du logiciel d'exploitation. Sur le MS-DOS et le Windows 3X (c'est-à-dire, avant Microsoft Windows 9X), le fichier a dû utiliser le format 8.3. Le nom réel a dû avoir un maximum de 8 caractères avec des restrictions aux caractères qui pourraient être utilisées. L'utilisateur a dû également indiquer trois caractères après le point. Les trois caractères, connus sous le nom d'extension du fichier, ont été utilisés par le logiciel d'exploitation pour classifier le fichier. C'était tout à fait nécessaire pour ces logiciels d'exploitation de 8 bits et de 16 bits. Les diverses règles ont changé. Par exemple, les noms des dossiers et des fichier sur Microsoft Windows >= 95 peuvent avoir jusqu'à 255 caractères. L'extension du fichier est la plupart du temps laissée au jugement du programmeur mais les fichiers utilisent toujours des extensions. Des applications peuvent également être configurées pour sauvegarder différents types de fichiers; c'est-à-dire, les fichiers avec différentes extensions.

Author Note Qu moment ou nous écrivons ces leçons, les règles pour les noms de fichier de Microsoft Windows étaient sur le site Web de MSDN dans le secteur développement de Windows \ services Windows de base \ fichiers et documentation I/O\SDK \ stockage \ vue d'ensemble de stockage \ gestion de fichier \ créer, supprimer, et maintenance des fichiers \ nommer un fichier (parce que c'est un site Web et pas un livre, ses pages peuvent changer n'importe quand).

Basé sur ceci, si vous déclarez une variable string pour contenir le nom du fichier, vous pouvez simplement initialiser la variable avec le nom nécessaire et son extension. Voici un exemple :

using System;

class Exercise
{
    static int Main()
    {
	string NameOfFile = "Employees.spr";

	return 0;
    }
}

Étude pratiqueÉtude pratique : Indication du nom d'un fichier 

  1. Accédez au fichier IceScream.cs et ajoutez une nouvelle méthode publique appelée SaveOrder de type void comme suit :
     
    using System;
    
    namespace IceCream3
    {
        // This class is used to create and manage an ice scream
        // and to process an order
        public sealed class IceScream
        {
    
            . . . No Change
    
            // This method is used to display a receipt to the user
            public void DisplayReceipt()
            {
                . . . No Change
            }
    
            public void SaveOrder()
            {
                string NameOfFile;
    
                Console.Write("Please enter your initials or the " +
    			  "name we will use to remember your order: ");
                NameOfFile = Console.ReadLine();
            }
        }
    }using System;
    
    namespace IceCream3
    {
        delegate void Request();
    
        // This class is used to create and manage an ice scream
        // and to process an order
        public sealed class IceScream
        {
            . . . No Change
    
            // This method is used to display a receipt to the user
            public void DisplayReceipt()
            {
                . . . No Change
            }
    
            public void SaveOrder()
            {
                string NameOfFile;
    
                Console.Write("Please enter your initials or the " +
                  "name we will use to remember your order: ");
                NameOfFile = Console.ReadLine();
            }
        }
    }
  2. Accédez au fichier Program.cs et changez le comme suit :
     
    using System;
    
    namespace IceCream3
    {
        class Program
        {
            static int Main(string[] args)
            {
                char answer = 'n';
                IceScream ic = new IceScream();
                Request process = new Request(ic.ProcessAnOrder);
    
                process();
    
                Console.Write("Do you want us to remember this " +
                              "order the next time you come to " +
                              "get your ice scream (y/n)? ");
                answer = char.Parse(Console.ReadLine());
    
                if (answer == 'y' || answer == 'Y')
                    ic.SaveOrder();
    
                return 0;
            }
        }
    }
  3. Exécutez le projet et l'examiner
  4. Fermez la fenêtre DOS

Le chemin d'un fichier

Si vous déclarez un string comme ci-dessus, le fichier sera créé dans un dossier comme une application. Autrement, vous pouvez créer votre nouveau fichier n'importe où dans le disque dur ou sur un autre médium. Pour faire cela, vous devez fournir un chemin complet où le fichier résidera. Un chemin est un string qui indique le disque (telle que A : , C : , ou D : , etc.). Les sections d'un chemin complet sont séparées par un antislash. Par exemple, un chemin peut être fait d'un dossier suivie du nom du fichier. Un exemple serait

C:\Palermo.tde  

Un chemin peut également consister en une unité de disque suivie du nom du dossier dans lequel le fichier sera créé. Voici un exemple :

C:\Program Files\Palermo.tde

Un chemin peut également indiquer que le fichier sera créé dans un dossier qui elle-même est à l'intérieur de d'un autre dossier. Dans ce cas-ci, se rappeler que les noms des dossiers doivent être séparés par des antislashs.

Dans la leçon 2, nous avons vu que le caractère antislash est utilisé pour créer ou contrôler des séquences d'évasion et il peut être inclus en valeur de string pour composer une séquence d'évasion. Pour cette raison, chaque fois que vous incluez un antislash dans un string, le compilateur pense que vous essayez de fournir une séquence d'évasion. Dans ce cas-ci, si la combinaison de l'antislash et du caractère qui suit l'antislash n'est pas identifiée comme séquence d'évasion, vous obtiendriez une erreur. Pour résoudre ce problème, vous avez deux solutions de rechange. Pour indiquer que l'antislash doit être considéré comme caractère de son propre chef, vous pouvez le doubler. Voici les exemples :

using System;

class Exercise
{
    static int Main()
    {
	string NameOfFile = "C:\\Documents and " +
			    "Settings\\Business Records\\Employees.spr";

	return 0;
    }
}

Comme alternative, vous pouvez maintenir un antislash dans chaque placeholder mais précéder la valeur de la chaîne (string) avec le symbole @. Voici un exemple :

using System;

class Exercise
{
    static int Main()
    {
	string NameOfFile = @"C:\Documents and " +
			     "Settings\Business Records\Employees.spr";

	return 0;
    }
}

De la même manière, vous pouvez déclarer une variable string pour représenter le nom d'un fichier existant que vous projetez utiliser dans votre programme. Vous pouvez également représenter son chemin.

Quand vous fournissez un chemin au fichier, si l'unité de disque que vous indiquez n'existe pas ou ne peut pas être lu, le compilateur considérerait que le fichier n'existe pas. Si vous fournissez les dossiers qui n'existent pas dans l'unité de disque, le compilateur considérerait que le fichier n'existe pas. Ceci signifie également que le compilateur ne créera pas les dossiers (.NET Framework fournit tous les moyens de créer un dossier mais vous devez demander au compilateur de le créer; simplement l'indication d'un dossier qui n'existe pas ne le créera pas automatiquement, même si vous créez un nouveau fichier). Par conséquent, il est de votre responsabilité de vous assurer que le fichier ou le chemin au fichier est valide. Car nous verrons dans la prochaine section, le compilateur peut vérifier l'existence d'un fichier ou d'un chemin.

  

Page d'Accueil Copyright © 2007, Yevol Suivant