Page d'Accueil

Interfaces

 

Introduction

Imaginez que vous commencez à créer une classe et, tout en la mettant en application ou en l'examinant, vous découvrez que cette classe particulière peut être utilisée à la place d'une base générale à partir de laquelle d'autres classes peuvent être dérivées. Une interface est une classe spéciale dont le but est de servir de modèle sur laquelle des classes actuelles peuvent être basées. Une interface est principalement créée comme une classe : elle a un nom, un corps et peut avoir des membres.

Pour créer une interface, au lieu du mot-clé class, utilisez le mot-clé interface. Par convention, le nom d'une interface commence par I. Voici un exemple :

interface ICourtDimensions
{
}

Étude pratique Étude pratique : Présentation des interfaces

  1. Sur le menu principal, cliquez projet - > Ajouter nouvel article…
  2. Dans les modèles énumérés, cliquez interface
  3. Placez le nom quadrilatère et cliquez Ajouter
  4. Changez le fichier comme suit :
     
    using System;
    
    namespace Geometry2
    {
        interface IQuadrilateral
        {
        }
    }
  5. Sauvegardez le fichier

Les membres d'une interface

Comme fait pour une classe, les membres d'une interface sont énumérés dans son corps. Dans une interface, vous ne pouvez pas déclarer des champs comme ceux que nous avons utilisés dans d'autres classes. Au lieu de cela, si vous voulez un certain type de variable membre, vous pouvez créer une propriété. Si vous créez une propriété dans une interface, vous ne pouvez pas définir cette propriété. Une des règles d'une interface est que vous ne pouvez définir aucun de ses membres. C'est également valide pour ses propriétés. Par conséquent, si vous créez une propriété dans une interface :

  • Vous pouvez indiquer qu'elle serait en lecture uniquement (read-only) en lui ajoutant get, une propriété d'acquisition vide. Voici un exemple :
     
    public interface ICourtDimensions
    {
    	double Length { get; }
    }
  • Vous pouvez indiquer que ce serait en écriture uniquement (write-only) en lui ajoutant set, une propriété de poseur vide. Voici un exemple :
     
    public interface ICourtDimensions
    {
    	double Length { set; }
    }
  • Vous pouvez indiquer qu'elle serait utilisée pour y écrire des valeurs et pour y lire des valeurs. Pour fournir ces informations, ajoutez lui des accessoires d'un acquéreur (get) et  d'un poseur (set). Voici un exemple :
     
    public interface ICourtDimensions
    {
    	double Length { get; set; }
    }

De la même manière, vous pouvez créer autant de propriétés que vous jugez nécessaire dans une interface. en plus des propriétés, une interface peut également avoir d'autres types de membres tels que des méthodes. Voici un exemple d'une interface qui a une propriété lecture seul (read-only) appelée NameOfSport, une propriété lecture/écriture appelée NumberOfPlayers, et une méthode appelée SportCharacteristics:

public interface IBall
{
	int NumberOfPlayers
	{
		get;
		set;
	}

	string NameOfSport
	{
		get;
	}

	void SportCharacteristics();
}

Étude pratique Étude pratique : Créer des membres d'une interface

  1. Pour créer une propriété, changez le fichier comme suit :
     
    using System;
    
    namespace Geometry2
    {
        interface IQuadrilateral
        {
            double Area { get; }
        }
    }
  2. sauvegardez le fichier

Une interface comme classe de base

Une interface est utilisée pour créer une base pour d'autres classes. Pour cette raison, c'est le candidat principal pour la dérivation de classe. Pour dériver d'une interface, utilisez la même technique que nous avons appliquée jusqu'ici dans la transmission. Voici un exemple d'une classe appelée SportBall qui dérive d'une interface appelée ISportType :

public class SportBall : ISportType
{
    int players;
    string sport;
}

Exactement comme vous pouvez dériver une classe d'une interface, vous pouvez créer une interface qui est elle-même basée sur une autre interface. Voici un exemple :

public interface ISportType : IBall
{
    SportCategory Type
    {
	get;
    }
}

Le langage C# ne permet pas la transmission multiple, qui est la capacité de créer une classe basée sur plus d'une classe. On permet la transmission multiple seulement si les bases sont des interfaces. Pour créer la transmission multiple, séparez les noms de l'interface, avec une virgule. Voici un exemple :

public interface ISportType : IBall, ICourtDimensions
{
    SportCategory Type
    {
	get;
    }
}

Vous pouvez également impliquer une classe comme parent dans un scénario de multiple transmission mais il doit y avoir seulement une classe. Voici un exemple dans lequel une classe appelée Sports dérive d'une classe de diverses interfaces :

public interface Sports: Player, IBall, ICourtDimensions
{
}

Étude pratique Étude pratique : Transmission à partir d'une interface

  1. Sur le menu principal, cliquez projet - > Ajouter nouvel article…
  2. Dans les modèles énumérés, cliquea interface
  3. Placez le nom RightAngle et cliquez Ajouter
  4. Changez le fichier comme suit :
     
    using System;
    
    namespace Geometry2
    {
        interface IRightAngle : IQuadrilateral
        {
            double Base { get; set; }
            double Height { get; set; }
            double Perimeter { get; }
        }
    }
  5. Accédez au fichier Square.cs et changez le comme suit :
     
    using System;
    
    namespace Geometry2
    {
        public class Square : ShapeDescription, IRightAngle
        {
            . . .
        }
    }
  6. Accédez au fichier Rectangle.cs et changez le comme suit :
     
    using System;
    
    namespace Geometry2
    {
        public class Rectangle : ShapeDescription, IRightAngle
        {
            . . .
        }
    }
  7. Sauvegardez tous

Application des classes dérivées d'une interface

Après avoir créé une interface, vous pouvez dériver d'elle d'autres interfaces ou d'autres classes. Si vous dérivez d'autres interfaces d'une interface, vous pouvez juste procéder comme vous voulez. Par exemple, vous pouvez ajouter ou ne pas ajouter une ou plusieurs nouvelles propriétés, vous pouvez ajouter ou ne pas ajouter une ou plusieurs méthodes, etc. Voici un exemple :

Fichier source : Preparation.cs
public enum SportCategory
{
	SinglePlayer,
	Collective,
	Unknown
}

public interface ICourtDimensions
{
	double Length { get; set; }
	double Width  { get; set; }
}

public interface IBall
{
	int NumberOfPlayers
	{
		get;
		set;
	}

	string NameOfSport
	{
		get;
	}

	void SportCharacteristics();
}

public interface ISportType : IBall, ICourtDimensions
{
	SportCategory Type
	{
		get;
	}
}

Si vous dérivez une classe d'une interface, vous devez mettre en application toutes les propriétés qui ont été créées dans l'interface. Ceci signifie que vous devez les définir de sorte que, quand une variable est déclarée de cette classe, les propriétés aient une signification. De la même manière, si vous créez une classe qui est basée sur une interface, vous devez appliquer toutes les méthodes qui ont été déclarées dans l'interface. Si vous dérivez une classe d'une interface qui elle-même a été dérivée d'une autre interface, dans votre classe, vous devez définir toutes les propriétés qui ont été créées dans toute la lignée parentale et vous devez appliquer toutes les méthodes qui ont été créées dans les interfaces parent et  grand-parent. Voici un exemple :

Fichier source : Sport.cs
using System;

public class SportBall : ISportType
{
	int players;
	string sport;
	SportCategory _type;
	double Len;
	double Wdt;
    
	public SportBall(int nbr, SportCategory tp, string name)
	{
		players = nbr;
		_type   = tp;
		sport   = name;
	}

	public int NumberOfPlayers
	{
		get	{ return players;}
		set	{ players = value;}
	}

	public string NameOfSport
	{
		get	{ return sport; }
	}

	public SportCategory Type
	{
		get	{ return _type; }
	}

	public double Length
	{
		get { return Len; }
		set { Len = value; }
	}

	public double Width
	{
		get { return Wdt; }
		set { Wdt = value; }
	}

	public void SportCharacteristics()
	{
		Console.WriteLine("Sport Characteristics");
		Console.WriteLine("Name of Sport: {0}", NameOfSport);
		Console.WriteLine("Type of Sport: {0}", Type);
		Console.WriteLine("# of Players:  {0}", NumberOfPlayers);
		Console.WriteLine("Court Dimensions: {0}m x {1}m", Len, Wdt);
	}
}

Une fois que la classe est prête, vous pouvez alors l'tiliser comme vous voulez. Voici un exemple :

Fichier source : Exercise.cs
using System;

class Exercise
{
    static void Main()
    {
	SportBall volley = new SportBall(6,
					 SportCategory.Collective,
					 "Volley Ball");
	volley.Length = 18;
	volley.Width  = 9;
	volley.SportCharacteristics();

	Console.WriteLine();

	SportBall tennis = new SportBall(1,
					 SportCategory.SinglePlayer,
					 "Table Tennis");
	tennis.Length = 23.7;
	tennis.Width  = 8.25;
	tennis.SportCharacteristics();

	Console.WriteLine();
    }
}

Ceci produirait :

Sport Characteristics
Name of Sport: Volley Ball
Type of Sport: Collective
# of Players:  6
Court Dimensions: 18m x 9m

Sport Characteristics
Name of Sport: Table Tennis
Type of Sport: SinglePlayer
# of Players:  1
Court Dimensions: 23.7m x 8.25m

Étude pratique Étude pratique : Mettre en application les membres dérivés d'une interface

  1. Accédez au fichier Square.cs et changez le comme suit :
     
    using System;
    
    namespace Geometry2
    {
        public class Square : ShapeDescription, IRightAngle
        {
            private double _side;
    
            public Square()
            {
                _side = 0.00;
            }
    
            public Square(double s)
            {
                _side = s;
            }
    
            public override string Name
            {
                get { return "Square"; }
            }
    
            public override string Description()
            {
                // Get the introduction from the parent
                string Introduction = base.Description() + " " +
                    "A square is a quadrilateral that has four " +
                      "equal sides and four right angles";
    
                return Introduction;
            }
    
            public double Base
            {
                get { return (_side < 0) ? 0.00 : _side; }
                set { _side = value; }
            }
    
            public double Height
            {
                get { return (_side < 0) ? 0.00 : _side; }
                set { _side = value; }
            }
    
            public double Area
            {
                get { return Base * Base; }
            }
    
            public double Perimeter
            {
                get { return Base * 4; }
            }
        }
    }
  2. Accédez au fichier Rectangle.cs et changez le comme suit :
     
    using System;
    
    namespace Geometry2
    {
        public class Rectangle : ShapeDescription, IRightAngle
        {
            double _length;
            double _height;
    
            public Rectangle()
            {
                _length = 0.00;
                _height = 0.00;
            }
    
            public Rectangle(double L, double H)
            {
                _length = L;
                _height = H;
            }
    
            public override string Name
            {
                get { return "Rectangle"; }
            }
    
            public override string Description()
            {
                // Get the introduction from the parent
                string Introduction = base.Description();
    
                string Msg = Introduction + " " +
                      "\nA rectangle is a quadrilateral that has adjacent " +
                "perpendicular sides. This implies that its four " +
                             "angles are right.";
                return Msg;
            }
    
            public double Base
            {
                get { return _length; }
                set { _length = value; }
            }
    
            public double Height
            {
                get { return _height; }
                set { _height = value; }
            }
    
            public double Area
            {
                get{ return Base * Height; }
            }
    
            public double Perimeter
            {
                get { return 2 * (Base + Height); }
            }
        }
    }
  3. Accédez au fichier Program.cs et changez le comme suit :
     
    using System;
    
    namespace Geometry2
    {
        public class Program
        {
            static Square CreateASquare()
            {
                double side;
    
                Console.Write("Enter the side of the square: ");
                side = double.Parse(Console.ReadLine());
    
                Square Sqr = new Square(side);
                return Sqr;
            }
    
            static void DisplaySquare(Square S)
            {
                Console.WriteLine("Square Characteristics");
                Console.WriteLine("Name:        {0}", S.Name);
                Console.WriteLine("Description: {0}", S.Description());
                Console.WriteLine("----------------------------");
                Console.WriteLine("Side:        {0}", S.Base);
                Console.WriteLine("Perimeter:   {0}", S.Perimeter);
                Console.WriteLine("Area:        {0}", S.Area);
            }
    
    
            static Rectangle CreateARectangle()
            {
                double Len, Hgt;
    
                Console.WriteLine("Enter the dimensions of the rectangle");
                Console.Write("Base:   ");
                Len = double.Parse(Console.ReadLine());
                Console.Write("Height: ");
                Hgt = double.Parse(Console.ReadLine());
    
                Rectangle Recto = new Rectangle(Len, Hgt);
                return Recto;
            }
    
            static void DisplayRectangle(Rectangle R)
            {
                Console.WriteLine("Rectangle Characteristics");
                Console.WriteLine("Name:        {0}", R.Name);
                Console.WriteLine("Description: {0}", R.Description());
                Console.WriteLine("----------------------------");
                Console.WriteLine("Base:        {0}", R.Base);
                Console.WriteLine("Height:      {0}", R.Height);
                Console.WriteLine("Perimeter:   {0}", R.Perimeter);
                Console.WriteLine("Area:        {0}", R.Area);
            }
    
            static void Main()
            {
                Square Sq = new Square();
                Rectangle Rect = new Rectangle();
    
                Sq = CreateASquare();
                Rect = CreateARectangle();
    
                Console.WriteLine("============================");
                DisplaySquare(Sq);
                Console.WriteLine("============================");
                DisplayRectangle(Rect);
                Console.WriteLine("============================");
    
                Console.WriteLine();
            }
        }
    }
  4. Exécutez l'application et l'examiner. Voici un exemple :
     
    Enter the side of the square: 44.16
    Enter the dimensions of the rectangle
    Base:   58.62
    Height: 36.06
    ============================
    Square Characteristics
    Name:        Square
    Description: A quadrilateral is a geometric figure that has 
    four sides and four angles. A square is a quadrilateral that 
    has four equal sides and four right angles
    ----------------------------
    Side:        44.16
    Perimeter:   176.64
    Area:        1950.1056
    ============================
    Rectangle Characteristics
    Name:        Rectangle
    Description: A quadrilateral is a geometric figure that has 
    four sides and four angles.
    A rectangle is a quadrilateral that has adjacent perpendicular 
    sides. This implies that its four angles are right.
    ----------------------------
    Base:        58.62
    Height:      36.06
    Perimeter:   189.36
    Area:        2113.8372
    ============================
    
    Press any key to continue . . .
  5. Fermez la fenêtre DOS
  

Page d'Accueil Copyright © 2007, Yevol