Hier is wat code van MSDN:

// compile with: /target:library 
public class D
{
    public virtual void DoWork(int i)
    {
        // Original implementation.
    }
}
public abstract class E : D
{
    public abstract override void DoWork(int i);
}
public class F : E
{
    public override void DoWork(int i)
    {
        // New implementation.
    }
}

Kan iemand bovenstaande code uitleggen met betrekking tot de verschillen tussen abstracte en virtuele methoden?

Antwoord 1, autoriteit 100%

Virtuele methoden hebben een implementatie en bieden de afgeleide klassen de mogelijkheid om deze te overschrijven. Abstracte methoden bieden geen implementatie en dwingen de afgeleide klassen om de methode te overschrijven.

Dus abstracte methoden bevatten geen echte code, en subklassen MOETEN de methode overschrijven. Virtuele methoden kunnen code hebben, wat meestal een standaardimplementatie van iets is, en alle subklassen KUNNEN de methode overschrijven met behulp van de override-modifier en een aangepaste implementatie bieden.

public abstract class E
{
    public abstract void AbstractMethod(int i);
    public virtual void VirtualMethod(int i)
    {
        // Default implementation which can be overridden by subclasses.
    }
}
public class D : E
{
    public override void AbstractMethod(int i)
    {
        // You HAVE to override this method
    }
    public override void VirtualMethod(int i)
    {
        // You are allowed to override this method.
    }
}

Antwoord 2, autoriteit 17%

Allereerst moet je het verschil weten tussen een virtuele en abstracte methode.

Abstracte methode

• Abstracte methode bevindt zich in de abstracte klasse en heeft geen hoofdtekst.
• Abstracte methode moet worden overschreven in niet-abstracte onderliggende klassen.

Virtuele methode

• Virtuele methode kan in abstracte en niet-abstracte klassen voorkomen.
• Het is niet nodig om de virtuele methode in de afgeleide te overschrijven, maar het kan wel.
• Virtuele methode moet body hebben ….kan worden overschreven door “override keyword”…..

Antwoord 3, autoriteit 3%

Abstracte methode:

• Als een abstracte methode is gedefinieerd in een klasse, moet de klasse
  declareren als een abstracte klasse.

• Een abstracte methode mag alleen een methodedefinitie bevatten, mag niet
  Bevat de hoofdtekst/implementatie van de methode.

• Een abstracte methode moet worden overschreven in de afgeleide klasse.

Virtuele methode:

• Virtuele methoden kunnen worden overschreven in de afgeleide klasse, maar niet
  verplicht.
• Virtuele methoden moeten de body/implementatie van de methode hebben
  met de definitie.

Voorbeeld:

public abstract class baseclass
        {
            public abstract decimal getarea(decimal Radius);
            public virtual decimal interestpermonth(decimal amount)
            {
                return amount*12/100;
            }
            public virtual decimal totalamount(decimal Amount,decimal principleAmount)
            {
                return Amount + principleAmount;
            }
        }
        public class derivedclass:baseclass
        {
            public override decimal getarea(decimal Radius)
            {
                return 2 * (22 / 7) * Radius;
            }
            public override decimal interestpermonth(decimal amount)
            {
                return amount * 14 / 100;
            }
        }

Antwoord 4

een abstracte methode moet call-override zijn in afgeleide klasse, anders geeft het een compileerfout
en in virtueel kun je het wel of niet negeren, het hangt ervan af of het goed genoeg is, gebruik het

Voorbeeld:

abstract class twodshape
{
    public abstract void area(); // no body in base class
}
class twodshape2 : twodshape
{
    public virtual double area()
    {
        Console.WriteLine("AREA() may be or may not be override");
    }
}