Come forzare le sottoclassi per implementare un metodo

Puoi avere metodi astratti in una classe con altri metodi implementati. Il vantaggio rispetto a un'interfaccia è che puoi includere del codice con la tua classe e fare in modo che il nuovo oggetto venga forzato a compilare i dettagli per i metodi astratti.

public abstract class YourClass
{
    // Your class implementation

    public abstract void DoSomething(int x, int y);

    public void DoSomethingElse(int a, string b)
    {
        // You can implement this here
    }
}

Questo non è del tutto corretto. Se la classe base è astratta, puoi contrassegnare come astratti i metodi che appartengono all'interfaccia e forzarne l'implementazione nelle sottoclassi.

Ciò porta un'opzione che non hai menzionato:usare entrambi. Hai un IFoo interfaccia e un FooBase classe base astratta la implementa o parte di essa. Ciò fornisce alle sottoclassi un'implementazione "predefinita" dell'interfaccia (o parte di essa) e consente anche di ereditare da qualcos'altro e implementare comunque l'interfaccia, o se si desidera implementare l'interfaccia ma non ereditare l'implementazione della classe base. Un esempio potrebbe aiutare:

// Your interface
interface IFoo { void A(); void B; }

// A "default" implementation of that interface
abstract class FooBase : IFoo
{
    public abstract void A();

    public void B()
    {
        Console.WriteLine("B");
    }
}

// A class that implements IFoo by reusing FooBase partial implementation
class Foo : FooBase
{
    public override void A()
    {
        Console.WriteLine("A");
    }
}

// This is a different class you may want to inherit from
class Bar
{
    public void C()
    {
        Console.WriteLine("C");
    }
}

// A class that inherits from Bar and implements IFoo
class FooBar : Bar, IFoo
{
    public void A()
    {
        Console.WriteLine("Foobar.A");
    }
    public void B()
    {
        Console.WriteLine("Foobar.B");
    }
}

Una classe astratta non richiede che tutte le funzioni che fornisce siano astratte.

abstract class Base {
    public void Foo() {} // Ordinary method
    public virtual void Bar() {} // Can be overridden
    public abstract void Xyz(); // This one *must* be overridden
}

Nota che se sostituisci public con protected , il metodo contrassegnato sarà solo visibile alle classi base e alle sottoclassi.