¿Métodos virtuales puros en C#?

Question

Me han dicho que hacer mi clase abstracta:

public abstract class Airplane_Abstract 

Y para hacer un método llamado mover

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

y que otros 4 métodos deben ser virtual "métodos virtuales puros". ¿Qué es eso exactamente?

Todos ellos se parecen a esto ahora:

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 
} 

Answer 1

Mi conjetura es que quienquiera le dijo a escribir un método "virtual pura" era un programador de C++ en lugar de un programador de C# ... pero el equivalente es un método abstracto:

public abstract void TurnRight(); 

que las fuerzas subclases concretas para anular TurnRight con una implementación real.

Answer 2

Probablemente significa que los métodos deben ser marcados abstract.

public abstract void TurnRight(); 

A continuación, tendrá a implementarlos en las subclases, a diferencia de un método virtual vacío, donde la subclase no tendría que anularlo.

Answer 3

"Pure virtual" es la terminología de C++. El equivalente de C# es un método abstracto.

Answer 4

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

"En la programación orientada a objetos, una función virtual o método virtual es una función o método cuyo comportamiento puede ser anulado dentro de una clase que hereda por una función con la misma firma."

Google siempre es tu amigo.

Answer 5

Entonces no tiene una implementación en la clase Airplane_Abstract pero obliga a los consumidores "herederos" de la Clase a implementarlos.

La clase Airplane_Abstract no se puede utilizar hasta que herede e implemente las funciones abstractas.

Answer 6

O incluso se puede ir de interfaz, que se cree es necesaria alguna pequeña limitación:

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

Sin embargo, tendrá que poner en práctica todos la declaración de la función de ambos IControllable y ITurnable han asignado, de lo contrario un error del compilador ocurrira. Si desea una implementación virutal opcional, debe ir al abstract class para el método virtual con interface para el método virtual puro.

De hecho, hay una diferencia entre interface función y abstract función, que interface sólo declara la función, todas las funciones interface tiene que ir todo público, por lo que no hay propiedad de clase de fantasía tales como private o protected por lo que es muy rápido, mientras abstract función son método de clase real y sin aplicación y fuerza a la aplicación en la clase derivada, lo que puede poner private, protected y miembros de las variables de acceso con abstract funciones, y la mayoría de las veces es más lento porque las relaciones de herencia de clase se analizan en tiempo de ejecución. (aka vtable)

Answer 7

Una función virtual pura es la terminología de C++ pero en C# si una función que se implementa en la clase Derivada y esa clase derivada no es una clase abstracta.

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

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