Page d'Accueil

Exécution partielle de classe

 

Description

Dans toutes les classes que nous avons définies jusqu'ici, nous employions un fichier simple pour mettre en application la classe. Dans C#, vous pouvez créer une classe (la même classe) dans différents fichiers. Ceci signifie que vous pouvez commencer une classe dans un fichier et la continuer dans un autre fichier ou dans d'autres fichiers. Ceci est désigné sous le nom de exécution partielle.

Author Note

Si vous avez programmé dans C++ ou C++/CLI, ne confondez pas son entête et ses fichiers source avec l'exécution partielle des classes de C# . Dans C++ ou C++/CLI, vous pouvez inclure la structure d'une classe avec ses variables membre (appelées les champs dans C#) et la déclaration de ses méthodes. Dans C++, un fichier entête a l'extension .h. Voici un exemple de fichier entête de C++/CLI :

Dossier d'en-tête : Cylinder.h
#pragma once

using namespace System;

public ref class CCylinder
{
private:
    double rad;
    double hgt;

public:
    CCylinder(void);
    CCylinder(double radius, double height);

    property double Radius
    {
	double get() { return rad; }
	void set(double value) { rad = value; }
    }

    property double Height
    {
	double get() { return hgt; }
	void set(double value) { hgt = value; }
    }

    double Volume();
};

Dans C++, après avoir créé un fichier entête, vous pouvez créer son fichier source associé. Le fichier source a l'extention .cpp. Voici un exemple du fichier source correspondant au fichier entête ci-dessus :

Fichier source : Cylinder.cpp
#include "Cylinder.h"

CCylinder::CCylinder(void)
    : rad(0.00), hgt(0.00)
{
}

CCylinder::CCylinder(double radius, double height)
    : rad(radius), hgt(height)
{
}

double CCylinder::Volume()
{
    return rad * rad * hgt * Math::PI;
}

La classe ci-dessus peut être examinée avec ce qui suit :

Fichier source : Exercise.cpp
#include "Cylinder.h"

using namespace System;

CCylinder ^ Initialize()
{
    CCylinder ^ c = gcnew CCylinder(36.12, 18.84);
    return c;
}

const void Show(CCylinder ^ vol)
{
    Console::WriteLine(L"Radius: {0}", vol->Radius);
    Console::WriteLine(L"Height: {0}", vol->Height);
    Console::WriteLine(L"Volume: {0}", vol->Volume());
}

int main()
{
    CCylinder ^ cyl = Initialize();
    Show(cyl);

    return 0;
}
 

Comme que nous avons vu jusqu'ici, dans C#, nous ne pouvons pas simplement et seulement déclarer une méthode dans un fichier pour une exécution ultérieure (postérieure), comme fait dans C, C++, C++/CLI, et (Objet) Pascal. Dans C#, pour créer une classe dans diverses classes, commencez la classe dans un fichier mais précédez la du mot-clé class avec partial. Voici un exemple d'un fichier appelé first.cs qui contient quelques (2) champs privés et quelques (2) propriétés :

Fichier source : geometry1.cs
using System;

partial class Cylinder
{
    private double rad;
    private double hgt;

    public Cylinder(double radius, double height)
    {
        this.rad = radius;
        this.hgt = height;
    }

    public double Radius
    {
        get { return rad; }
	    set { rad = value; }
    }

    public double Height
    {
	    get { return hgt; }
	    set { hgt = value; }
    }
}

Après avoir créé la classe dans un fichier, vous pouvez l'utiliser comme toutes les classes telle que nous avons fait jusqu'ici. Voici un exemple :

Fichier source : Exercise.cs
using System;

class Program
{
    static Cylinder Initialize()
    {
        Cylinder c = new Cylinder(36.12, 18.84);
        return c;
    }

    static void Show(Cylinder vol)
    {
        Console.WriteLine("Radius: {0}", vol.Radius);
        Console.WriteLine("Height: {0}", vol.Height);
    }
   
    static int Main()
    {
        Cylinder cyl = Initialize();

        Show(cyl);

        Console.WriteLine();
        return 0;
    }
}

Ceci produirait :

Radius: 36.12
Height: 18.84

Press any key to continue . . .

Si vous aviez créé une classe partielle, ou que vous obteniez une classe partielle de quelqu'un (pas en tant qu'élément d'un DLL ou d'un autre type de bibliothèque), et vous découvrez que la classe n'est pas complète, vous pouvez alors la compléter. Une des règles que vous devez observer est que la classe partielle doit avoir été marquée comme partial, comme nous avons fait en haut. Un des avantages de l'exécution partielle est que vous n'avez pas retourner de nouveau au premier ou précédent fichier pour le modifier afin de compléter la classe. Vous pouvez simplement commencer un autre fichier et continuer la classe à l'intérieur. Deux autres règles que vous devez observer sont que vous devez utiliser le même nom pour la classe et vous devez le précéder du mot-clé class avec partial. Voici un exemple :

Fichier source : geometry2.cs
using System;

partial class Cylinder
{
    public Cylinder()
    {
        this.rad = 0.00;
        this.hgt = 0.00;
    }

    public double Volume()
    {
        return rad * rad * hgt * Math.PI;
    }
}

Cette classe peut alors être examinée comme suit :

Fichier source : Exercise.cs
using System;

class Program
{
    static Cylinder Initialize()
    {
        Cylinder c = new Cylinder();
        
        c.Radius = 42.66;
        c.Height = 26.48;

        return c;
    }

    static void Show(Cylinder vol)
    {
        Console.WriteLine("Radius: {0}", vol.Radius);
        Console.WriteLine("Height: {0}", vol.Height);
        Console.WriteLine("Volume: {0}", vol.Volume());
    }
   
    static int Main()
    {
        Cylinder cyl = Initialize();

        Show(cyl);

        Console.WriteLine();
        return 0;
    }
}

Ceci produirait :

Radius: 42.66
Height: 26.48
Volume: 151394.310951986

Press any key to continue . . .

Une fois qu'une classe partielle a été créée, vous pouvez créer des autres basés sur elle. La classe fille n'a pas besoin être partielle, bien qu'elle puisse l'être.

Étude pratique Étude pratique : Mettre en application une classe partielle

  1. Commencez Microsoft Visual C# et créez une application de console appelée Geometry3
  2. Pour ajouter un nouveau fichier source, sur le menu principal, cliquez projet - > Ajouter nouvel article…
  3. Dans les modèles énumérés, cliquez le fichier de code
  4. Placez le nom circle1 et cliquez Ajouter
  5. Changez le fichier comme suit :
     
    public partial class Circle
    {
        private double _radius;
    
        public double Radius
        {
            get { return (this._radius <= 0) ? 0.00 : this._radius; }
            set { this._radius = value; }
        }
    
        public double Diameter
        {
            get { return this.Radius * 2; }
        }
    
        public double Circumference
        {
            get { return Diameter * 3.14159; }
        }
    
        public double Area
        {
            get { return this.Radius * this.Radius * 3.14159; }
        }
    }
  6. Pour créer un nouveau fichier source, dans Explorateur de solution, cliquez Geometry3 - > Ajouter - > nouvel article…
  7. Dans les modèles énumérés, s'assurer que le fichier de code est sélectionné ; autrement, le cliquer.
    Placez le nom circle2 et cliquez Ajouter
  8. Changez le fichier comme suit :
     
    using System;
    
    public partial class Circle
    {
        public Circle()
        {
            this.Radius = 0.00;
        }
    
        public Circle(double radius)
        {
            this.Radius = radius;
        }
    
        public void Present()
        {
            Console.WriteLine("Radius:        {0}", this.Radius);
            Console.WriteLine("Diameter:      {0}", this.Diameter);
            Console.WriteLine("Circumference: {0}", this.Circumference);
            Console.WriteLine("Area:          {0}", this.Area);
        }
    }
  9. Pour examiner la classe, accédez au fichier Program.cs et le changer comme suit :
     
    using System;
    
    namespace Geometry3
    {
        class Program
        {
            static Circle Initialize()
            {
                Console.Write("Enter the radius: ");
                double rad = double.Parse(Console.ReadLine());
                
                Circle c = new Circle(rad);
                return c;
            }
    
            static int Main()
            {
                Console.WriteLine(
    		"This application allows you to process a circle");
                Circle circ = Initialize();
    
                Console.WriteLine("\n==============================");
                Console.WriteLine("Circle Characteristics");
                Console.WriteLine("------------------------------");
                circ.Present();
                Console.WriteLine("==============================\n");
               
                return 0;
            }
        }
    }
  10. Exécutez l'application pour voir le résultat. Voici un exemple :
     
    This application allows you to process a circle
    Enter the radius: 10.08
    
    ==============================
    Circle Characteristics
    ------------------------------
    Radius:        10.08
    Diameter:      20.16
    Circumference: 63.3344544
    Area:          319.205650176
    ==============================
    
    Press any key to continue . . .
  11. Revenez à votre environnement de programmation
  12. Pour créer un nouveau fichier source, sur le menu principal, cliquez projet  - > aAouter nouvel article…
  13. Dans les modèles énumérés, s'assurer que le fichier de code est sélectionné ; autrement, le cliquer.
    Placez le nom cylinder1 et lappuyez Enter
  14. Changez le fichier comme suit :
     
    using System;
    
    public partial class Cylinder : Circle
    {
        private double hgt;
    
        public double Height
        {
            get { return (this.hgt <= 0) ? 0.00 : this.hgt; }
            set { this.hgt = value; }
        }
    
        public double LateralArea
        {
            get { return this.Circumference * Height; }
        }
    
        public double TotalArea
        {
            get { return this.Area + this.LateralArea; }
        }
    
        public double Volume
        {
            get
            {
                return this.Radius * this.Radius * this.Height * Math.PI;
            }
        }
    }
  15. Pour créer un nouveau fichier source, dans Explorateur de solution, cliquez Geometry3 - > Ajouter - > nouvel article…
  16. Dans les modèles énumérés, s'assurer que le fichier de code est sélectionné ; autrement, le cliquer.
    Placez le nom Cylinder2 et cliquez Ajouter
  17. Changez le fichier comme suit :
  18.  
    using System;
    
    public partial class Cylinder : Circle 
    {
        // This is the default constructor of the cylinder
        // This constructor assumes that we don't have any dimension
        public Cylinder()
        {
            this.Radius = 0.00;
        }
    
        // This constructor assumes that there exists a radius
        // The radius could have been specified on a parent circle
        public Cylinder(double height)
        {
            this.Height = height;
        }
    
        // This constructor can be used to specify both
        // the radius of the base and the height of the volume
        // The radius can also have been defined by a parent circle
        public Cylinder(double radius, double height)
        {
            this.Radius = radius;
            this.Height = height;
        }
    
        new public void Present()
        {
            Console.WriteLine("Height:        {0}", this.Height);
            Console.WriteLine("Lateral Area:  {0}", this.LateralArea);
            Console.WriteLine("Total Area:    {0}", this.TotalArea);
            Console.WriteLine("Volume:        {0}", this.Volume);
        }
    }
  19. Pour examiner la classe, accédez au fichier Program.cs et le changer comme suit :
     
    using System;
    
    namespace Geometry3
    {
        class Program
        {
            static Circle Initialize()
            {
                Console.Write("Enter the radius: ");
                double rad = double.Parse(Console.ReadLine());
                
                Circle c = new Circle(rad);
                return c;
            }
    
            static double GetHeight()
            {
                Console.Write("Enter the height: ");
                double hgt = double.Parse(Console.ReadLine());
    
                return hgt;
            }
    
            static int Main()
            {
                Console.WriteLine(
    		"This application allows you to process a cylinder");
                Circle circ = Initialize();
                double height = GetHeight();
                Cylinder cldr = new Cylinder(circ.Radius, height);
    
                Console.WriteLine("\n================================");
                Console.WriteLine("=//=Cylinder Characteristics=//=");
                Console.WriteLine("================================");
                Console.WriteLine(" =-= Base Characteristics =-=");
                Console.WriteLine("--------------------------------");
                circ.Present();
                Console.WriteLine("------------------------------");
                Console.WriteLine("=-= Volume Characteristics =-=");
                cldr.Present();
                Console.WriteLine("================================\n");
               
                return 0;
            }
        }
    }
  20. Exécutez l'application pour voir le résultat. Voici un exemple :
     
    This application allows you to process a cylinder
    Enter the radius: 85.15
    Enter the height: 44.95
    
    ================================
    =//=Cylinder Characteristics=//=
    ================================
     =-= Base Characteristics =-=
    --------------------------------
    Radius:        85.15
    Diameter:      170.3
    Circumference: 535.012777
    Area:          22778.168980775
    ------------------------------
    =-= Volume Characteristics =-=
    Height:        44.95
    Lateral Area:  24048.82432615
    Total Area:    46826.993306925
    Volume:        1023879.5605199
    ================================
    
    Press any key to continue . . .
  21. Revenez à votre environnement de programmation
  

Page d'Accueil Copyright © 2007, Yevol