Differenza tra metodi virtuali e astratte

Question

Ecco il codice da 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. 
    } 
} 

Qualcuno può spiegare il codice di cui sopra per quanto riguarda le differenze tra i metodi astratti e virtuali?

Answer 1

I metodi virtuali hanno un'implementazione e forniscono alle classi derivate la possibilità di sovrascriverli. I metodi astratti non forniscono un'implementazione e costringono le classi derivate a sovrascrivere il metodo.

Quindi, i metodi astratti non contengono alcun codice effettivo e le sottoclassi DEVONO sovrascrivere il metodo. I metodi virtuali possono avere il codice, che di solito è un'implementazione predefinita di qualcosa, e qualsiasi sottoclasse PUI sovrascrivere il metodo utilizzando il modificatore override e fornire un'implementazione personalizzata.

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. 
    } 
} 

Answer 2

Prima di tutto è necessario conoscere la differenza tra un metodo virtuale e un metodo astratto.

astratta Metodo

• astratta Metodo risiede nella classe astratta e non ha corpo.
• Il metodo astratto deve essere sovrascritto in classe child non astratta.

virtuale Metodo

• metodo virtuale può risiedere in classe astratta e non astratta.
• Non è necessario sovrascrivere il metodo virtuale in derivato ma può esserlo.
• metodo virtuale deve avere il corpo .... può essere sostituito da "override parola chiave" .....

Answer 3

un metodo astratto deve essere override di chiamata nella classe derivata altro errore saggio che vi darà tempo di compilazione e nel virtuale che può o non può ignorare è dipende se è buono abbastanza usarlo

Esempio:

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

Answer 4

astratta Metodo:

• Se un metodo astratto viene definito in una classe, la classe deve dichiarare come classe astratta.

• Un metodo astratto deve contenere solo la definizione del metodo, non Contenere il metodo body/implementation.

• Un metodo astratto deve essere superato nella classe derivata.

Metodo virtuale:

• metodi virtuali possono essere over ride nella classe derivata ma non obbligatoria.
• I metodi virtuali devono avere il metodo corpo/implementazione lungo con la definizione.

Esempio:

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

     }