abstract (Riferimenti per C#)abstract (C# Reference)

Il modificatore abstract indica che l'oggetto in fase di modifica ha un'implementazione mancante o incompleta.The abstract modifier indicates that the thing being modified has a missing or incomplete implementation. Il modificatore abstract può essere usato con classi, metodi, proprietà, indicizzatori ed eventi.The abstract modifier can be used with classes, methods, properties, indexers, and events. Usare il modificatore abstract in una dichiarazione di classe per indicare che una classe verrà usata solo come classe di base per altre classi e che non verrà creata un'istanza relativamente alla stessa.Use the abstract modifier in a class declaration to indicate that a class is intended only to be a base class of other classes, not instantiated on its own. I membri contrassegnati come astratti devono essere implementati da classi non astratte che derivano dalla classe astratta.Members marked as abstract must be implemented by non-abstract classes that derive from the abstract class.

EsempioExample

In questo esempio, la classe Square deve eseguire un'implementazione di GetArea poiché deriva da Shape:In this example, the class Square must provide an implementation of GetArea because it derives from Shape:

abstract class Shape
{
    public abstract int GetArea();
}

class Square : Shape
{
    int side;

    public Square(int n) => side = n;

    // GetArea method is required to avoid a compile-time error.
    public override int GetArea() => side * side;

    static void Main() 
    {
        var sq = new Square(12);
        Console.WriteLine($"Area of the square = {sq.GetArea()}");
    }
}
// Output: Area of the square = 144

Le classi astratte hanno le caratteristiche seguenti:Abstract classes have the following features:

  • Non è possibile creare un'istanza di una classe astratta.An abstract class cannot be instantiated.

  • Una classe astratta può contenere funzioni di accesso e metodi astratti.An abstract class may contain abstract methods and accessors.

  • Non è possibile modificare una classe astratta con il modificatore sealed perché i due modificatori hanno significati opposti.It is not possible to modify an abstract class with the sealed modifier because the two modifiers have opposite meanings. Il modificatore sealed impedisce a una classe che venga ereditata e il modificatore abstract richiede una classe da ereditare.The sealed modifier prevents a class from being inherited and the abstract modifier requires a class to be inherited.

  • Una classe non astratta derivata da una classe astratta deve includere implementazioni effettive di tutte le funzioni di accesso e di tutti i metodi astratti ereditati.A non-abstract class derived from an abstract class must include actual implementations of all inherited abstract methods and accessors.

Usare il modificatore abstract in una dichiarazione di metodo o proprietà per indicare che il metodo o proprietà non contiene implementazioni.Use the abstract modifier in a method or property declaration to indicate that the method or property does not contain implementation.

I metodi astratti hanno le caratteristiche seguenti:Abstract methods have the following features:

  • Un metodo astratto è implicitamente un metodo virtuale.An abstract method is implicitly a virtual method.

  • Le dichiarazioni di metodi astratti sono consentite solo in classi astratte.Abstract method declarations are only permitted in abstract classes.

  • Poiché una dichiarazione di un metodo astratto non offre alcuna implementazione effettiva, non c'è nessun corpo del metodo. La dichiarazione del metodo termina semplicemente con un punto e virgola e non ci sono parentesi graffe ({ }) dopo la firma.Because an abstract method declaration provides no actual implementation, there is no method body; the method declaration simply ends with a semicolon and there are no curly braces ({ }) following the signature. Ad esempio:For example:

    public abstract void MyMethod();  
    

    L'implementazione viene specificata tramite l'override di un metodo, che è un membro di una classe non astratta.The implementation is provided by a method override, which is a member of a non-abstract class.

  • Non è possibile usare il modificatore static o virtual in una dichiarazione di un metodo astratto.It is an error to use the static or virtual modifiers in an abstract method declaration.

Le proprietà astratte si comportano come i metodi astratti, ad eccezione delle differenze nella sintassi di dichiarazione e di chiamata.Abstract properties behave like abstract methods, except for the differences in declaration and invocation syntax.

  • Non è possibile usare il modificatore abstract su una proprietà static.It is an error to use the abstract modifier on a static property.

  • Una proprietà astratta ereditata può essere sottoposta a override in una classe derivata includendo una dichiarazione di proprietà che usa il modificatore di override.An abstract inherited property can be overridden in a derived class by including a property declaration that uses the override modifier.

Per altre informazioni sulle classi astratte, vedere Classi e membri delle classi astratte e sealed.For more information about abstract classes, see Abstract and Sealed Classes and Class Members.

Una classe astratta deve specificare l'implementazione per tutti i membri di interfaccia.An abstract class must provide implementation for all interface members.

Una classe astratta che implementa un'interfaccia può eseguire il mapping dei metodi di interfaccia su metodi astratti.An abstract class that implements an interface might map the interface methods onto abstract methods. Ad esempio:For example:

interface I
{
    void M();
}
abstract class C : I
{
    public abstract void M();
}

EsempioExample

In questo esempio, la classe DerivedClass è derivata da una classe di base astratta BaseClass.In this example, the class DerivedClass is derived from an abstract class BaseClass. La classe astratta contiene un metodo astratto, AbstractMethod, e due proprietà astratte, X e Y.The abstract class contains an abstract method, AbstractMethod, and two abstract properties, X and Y.

abstract class BaseClass   // Abstract class
{
    protected int _x = 100;
    protected int _y = 150;
    public abstract void AbstractMethod();   // Abstract method
    public abstract int X    { get; }
    public abstract int Y    { get; }
}

class DerivedClass : BaseClass
{
    public override void AbstractMethod()
    {
        _x++;
        _y++;
    }

    public override int X   // overriding property
    {
        get
        {
            return _x + 10;
        }
    }

    public override int Y   // overriding property
    {
        get
        {
            return _y + 10;
        }
    }

    static void Main()
    {
        var o = new DerivedClass();
        o.AbstractMethod();
        Console.WriteLine($"x = {o.X}, y = {o.Y}");
    }
}
// Output: x = 111, y = 161

Nell'esempio precedente, se si prova a creare un'istanza della classe astratta tramite un'istruzione simile alla seguente:In the preceding example, if you attempt to instantiate the abstract class by using a statement like this:

BaseClass bc = new BaseClass();   // Error  

si ottiene un messaggio di errore che informa che il compilatore non può creare un'istanza della classe astratta "BaseClass".You will get an error saying that the compiler cannot create an instance of the abstract class 'BaseClass'.

Specifiche del linguaggio C#C# Language Specification

Per altre informazioni, vedere la specifica del linguaggio C#.For more information, see the C# Language Specification. La specifica del linguaggio costituisce il riferimento ufficiale principale per la sintassi e l'uso di C#.The language specification is the definitive source for C# syntax and usage.

Vedere ancheSee also