Come definire le proprietà astratte (Guida per programmatori C#)

  • Articolo

L'esempio seguente mostra come definire proprietà di tipo abstract. La dichiarazione di una proprietà astratta non fornisce un'implementazione delle funzioni di accesso della proprietà. Dichiara che la classe supporta le proprietà, ma l'implementazione delle funzioni di accesso viene demandata alle classi derivate. L'esempio seguente illustra come implementare le proprietà astratte ereditate da una classe di base.

L'esempio include tre file, ognuno dei quali viene compilato singolarmente e al cui assembly risultante viene fatto riferimento nella compilazione successiva:

  • abstractshape.cs: classe Shape che contiene una proprietà Area astratta.

  • shapes.cs: sottoclassi della classe Shape.

  • shapetest.cs: programma di test per la visualizzazione delle aree di alcuni oggetti derivati da Shape.

Per compilare l'esempio, usare il comando seguente:

csc abstractshape.cs shapes.cs shapetest.cs

Verrà creato il file eseguibile shapetest.exe.

Esempi

Questo file dichiara la classe Shape che contiene la proprietà Area del tipo double.

// compile with: csc -target:library abstractshape.cs
public abstract class Shape
{
    private string name;

    public Shape(string s)
    {
        // calling the set accessor of the Id property.
        Id = s;
    }

    public string Id
    {
        get
        {
            return name;
        }

        set
        {
            name = value;
        }
    }

    // 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}";
    }
}

  • I modificatori della proprietà vengono inseriti nella dichiarazione della proprietà stessa. Ad esempio:

    public abstract double Area

  • Quando si dichiara una proprietà astratta, come Area in questo esempio, è sufficiente indicare le funzioni di accesso disponibili per la proprietà, senza implementarle. In questo esempio è disponibile solo una funzione di accesso get, quindi la proprietà è di sola lettura.

Il codice seguente mostra tre sottoclassi di Shape e il modo in cui eseguono l'override della proprietà Area per fornire la propria implementazione.

// 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)
    {
        this.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)
    {
        this.radius = radius;
    }

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

public class Rectangle : Shape
{
    private int width;
    private int height;

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

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

Il codice seguente mostra un programma di test che crea diversi oggetti derivati da Shape e stampa le relative aree.

// 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")
        };

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

Vedi anche