Partager via

Guide pratique pour définir des propriétés abstraites (Guide de programmation C#)

L’exemple suivant montre comment définir des propriétés abstraites . Une déclaration de propriété abstraite ne fournit pas d’implémentation des accesseurs de propriété : elle déclare que la classe prend en charge les propriétés, mais laisse l’implémentation de l’accesseur aux classes dérivées. L’exemple suivant montre comment implémenter les propriétés abstraites héritées d’une classe de base.

Cet exemple se compose de trois fichiers, chacun d’entre eux étant compilé individuellement et son assembly résultant est référencé par la compilation suivante :

  • abstractshape.cs : classe Shape qui contient une propriété abstraite Area .

  • shapes.cs : sous-classes de la Shape classe.

  • shapetest.cs : programme de test pour afficher les zones de certains Shapeobjets dérivés.

Pour compiler l’exemple, utilisez la commande suivante :

csc abstractshape.cs shapes.cs shapetest.cs

Cela crée le fichier exécutable shapetest.exe.

Exemples

Ce fichier déclare la Shape classe qui contient la Area propriété du type double.

// compile with: csc -target:library abstractshape.cs
public abstract class Shape
{
    public Shape(string s)
    {
        // calling the set accessor of the Id property.
        Id = s;
    }

    public string Id { get; set; }

    // Area is a read-only property - only a get accessor is needed:
    public abstract double Area
    {
        get;
    }

    public override string ToString()
    {
        return $"{Id} Area = {Area:F2}";
    }
}

  • Les modificateurs sur la propriété sont placés sur la déclaration de propriété proprement dite. Par exemple:

    public abstract double Area

  • Lorsque vous déclarez une propriété abstraite (par Area exemple, dans cet exemple), vous indiquez simplement quels accesseurs de propriété sont disponibles, mais ne les implémentez pas. Dans cet exemple, seul un accesseur get est disponible. La propriété est donc en lecture seule.

Le code suivant montre trois sous-classes de Shape et comment ils remplacent la Area propriété pour fournir leur propre implémentation.

// compile with: csc -target:library -reference:abstractshape.dll shapes.cs
public class Square : Shape
{
    private int _side;

    public Square(int side, string id)
        : base(id)
    {
        _side = side;
    }

    public override double Area
    {
        get
        {
            // Given the side, return the area of a square:
            return _side * _side;
        }
    }
}

public class Circle : Shape
{
    private int _radius;

    public Circle(int radius, string id)
        : base(id)
    {
        _radius = radius;
    }

    public override double Area
    {
        get
        {
            // Given the radius, return the area of a circle:
            return _radius * _radius * Math.PI;
        }
    }
}

public class Rectangle : Shape
{
    private int _width;
    private int _height;

    public Rectangle(int width, int height, string id)
        : base(id)
    {
        _width = width;
        _height = height;
    }

    public override double Area
    {
        get
        {
            // Given the width and height, return the area of a rectangle:
            return _width * _height;
        }
    }
}

Le code suivant montre un programme de test qui crée un certain nombre d’objets Shapedérivés et imprime leurs zones.

// compile with: csc -reference:abstractshape.dll;shapes.dll shapetest.cs
class TestClass
{
    static void Main()
    {
        Shape[] shapes =
        [
            new Square(5, "Square #1"),
            new Circle(3, "Circle #1"),
            new Rectangle( 4, 5, "Rectangle #1")
        ];

        Console.WriteLine("Shapes Collection");
        foreach (Shape s in shapes)
        {
            Console.WriteLine(s);
        }
    }
}
/* Output:
    Shapes Collection
    Square #1 Area = 25.00
    Circle #1 Area = 28.27
    Rectangle #1 Area = 20.00
*/

Voir aussi