web-dev-qa-db-fra.com

Méthodes virtuelles pures en C #?

On m'a dit de faire un résumé de ma classe:

public abstract class Airplane_Abstract

Et pour rendre virtuelle une méthode appelée move

 public virtual void Move()
        {
            //use the property to ensure that there is a valid position object
            double radians = PlanePosition.Direction * (Math.PI / 180.0);

            // change the x location by the x vector of the speed
            PlanePosition.X_Coordinate += (int)(PlanePosition.Speed * Math.Cos(radians));

            // change the y location by the y vector of the speed
            PlanePosition.Y_Coordinate += (int)(PlanePosition.Speed * Math.Sin(radians));
        }

Et que 4 autres méthodes devraient être des "méthodes virtuelles pures". Qu'est-ce que c'est exactement?

Ils ressemblent tous à ceci en ce moment:

public virtual void TurnRight()
{
    // turn right relative to the airplane
    if (PlanePosition.Direction >= 0 && PlanePosition.Direction < Position.MAX_COMPASS_DIRECTION)
        PlanePosition.Direction += 1;
    else
        PlanePosition.Direction = Position.MIN_COMPASS_DIRECTION;  //due north
}
c#abstract-classpure-virtual
38
David Brewer

Je suppose que celui qui vous a dit d'écrire une méthode "pure virtuelle" était un programmeur C++ plutôt qu'un programmeur C # ... mais l'équivalent est une méthode abstraite:

public abstract void TurnRight();

Cela oblige les sous-classes concrètes à remplacer TurnRight par une implémentation réelle.

74
Jon Skeet

"Pure virtual" est la terminologie C++. L'équivalent C # est une méthode abstraite.

11
David Yaw

Ils signifient probablement que les méthodes doivent être marquées abstract.

 public abstract void TurnRight();

Vous devrez ensuite les implémenter dans les sous-classes, par opposition à une méthode virtuelle vide, où la sous-classe n'aurait pas à la remplacer.

8
Justin

Ou même vous pouvez aller à l'interface, pensant qu'une petite limitation est requise:

public interface IControllable
{
    void Move(int step);
    void Backward(int step);
}

public interface ITurnable
{
   void TurnLeft(float angle);
   void TurnRight(float angle);
}

public class Airplane : IControllable, ITurnable
{
   void Move(int step)
   {
       // TODO: Implement code here...
   }
   void Backward(int step)
   {
       // TODO: Implement code here...
   }
   void TurnLeft(float angle)
   {
       // TODO: Implement code here...
   }
   void TurnRight(float angle)
   {
       // TODO: Implement code here...
   }
}

Cependant, vous devrez implémenter tout la déclaration de fonction des deux IControllable et ITurnable ont affecté, sinon une erreur de compilation se produira. Si vous voulez une implémentation virutale facultative, vous devrez aller abstract class pour la méthode virtuelle avec interface pour la méthode virtuelle pure.

En fait, il existe une différence entre la fonction interface et la fonction abstract, que interface déclare uniquement la fonction, toutes les fonctions interface doivent être rendus publics, donc il n'y a pas de propriété de classe fantaisie comme private ou protected donc c'est très rapide, tandis que la fonction abstract est méthode de classe réelle sans implémentation et force l'implémentation dans la classe dérivée, vous pouvez donc mettre private, protected et accéder aux variables membres avec les fonctions abstract, et la plupart du temps c'est plus lent car les relations d'héritage de classe sont analysées en temps d'exécution. (alias vtable)

4
Steve Fan

Une fonction virtuelle pure est la terminologie de C++ mais en C # si une fonction qui est implémentée dans une classe dérivée et cette classe dérivée n'est pas une classe abstraite.

abstract class PureVirtual
{
    public abstract void PureVirtualMethod();
}

class Derivered : PureVirtual
{
    public override void PureVirtualMethod()
    {
        Console.WriteLine("I'm pure virtual function");
    }
}
4
AuserP

Vous n'avez alors pas d'implémentation dans la classe Airplane_Abstract mais forcez les consommateurs "héritiers" de la classe à les implémenter.

La classe Airplane_Abstract est inutilisable jusqu'à ce que vous héritiez et implémentiez les fonctions abstraites.

2
AnthonyLambert

http://en.wikipedia.org/wiki/Virtual_function

"Dans la programmation orientée objet, une fonction virtuelle ou une méthode virtuelle est une fonction ou une méthode dont le comportement peut être remplacé au sein d'une classe héritée par une fonction avec la même signature."

Google est toujours votre ami.

1
dotalchemy