Condividi tramite

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

Nell'esempio seguente viene illustrato come definire le proprietà astratte . Una dichiarazione di proprietà astratta non fornisce un'implementazione delle funzioni di accesso alle proprietà. Dichiara che la classe supporta le proprietà, ma lascia l'implementazione della funzione di accesso alle classi derivate. Nell'esempio seguente viene illustrato come implementare le proprietà astratte ereditate da una classe di base.

Questo esempio è costituito da tre file, ognuno dei quali viene compilato singolarmente e il relativo assembly risultante fa riferimento alla compilazione successiva:

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

  • shapes.cs: sottoclassi della Shape classe .

  • shapetest.cs: programma di test per visualizzare le aree di alcuni Shapeoggetti derivati.

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 Shape classe che contiene la Area proprietà del tipo 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}";
    }
}

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

    public abstract double Area

  • Quando si dichiara una proprietà astratta , ad esempio Area in questo esempio, è sufficiente indicare quali funzioni di accesso alle proprietà sono disponibili, ma non implementarle. In questo esempio è disponibile solo una funzione di accesso get , quindi la proprietà è di sola lettura.

Il codice seguente illustra tre sottoclassi di Shape e come eseguire 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)
    {
        _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;
        }
    }
}

Il codice seguente mostra un programma di test che crea un certo numero di Shape oggetti derivati 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")
        ];

        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
*/

Vedere anche

  • Last updated on