¿Hay alguna diferencia entre "base" y "esto" cuando se hace referencia al campo, propiedad o método objeto primario?

Question

Considere el siguiente código:

public class Vehicle 
{ 
    public void StartEngine() 
    { 
     // Code here. 
    } 
} 

public class CityBus : Vehicle 
{ 
    public void MoveToLocation(Location location) 
    { 
     ////base.StartEngine(); 
     this.StartEngine(); 
     // Do other stuff to drive the bus to the new location. 
    } 
} 

¿Hay alguna diferencia entre this.StartEngine(); y base.StartEngine();, excepto que en el segundo caso, StartEngine método no se puede mover o anulados a CityBus clase? ¿Hay un impacto en el rendimiento?

Answer 1

La única diferencia es una llamada explícita para ver su clase principal frente a una implícita que termina en el mismo lugar a través de la herencia simple. La diferencia de rendimiento es insignificante. como dijo Hans Passant, una llamada a base.StartEngine() causará un comportamiento extraño si hace que StartEngine sea virtual en algún momento.

No necesita ningún calificador para obtener el lugar correcto. this.StartEngine() es casi siempre redundante cuando se codifica explícitamente. Es posible que tenga código que pone una referencia indirecta this en una lista de objetos, pero entonces es la referencia en la lista que se llama:

public class Vehicle 
{ 
    public void StartEngine() 
    { 
     // Code here. 
    } 

    //For demo only; a method like this should probably be static or external to the class 
    public void GentlemenStartYourEngines(List<Vehicle> otherVehicles) 
    { 
     otherVehicles.Add(this); 

     foreach(Vehicle v in Vehicles) v.StartEngine(); 
    } 
} 

Answer 2

Sin diferencias, StartEngine() no es virtual. No debe usar base, en caso de que alguna vez la refactorice para hacerlo virtual. El rendimiento diff no es mensurable.

Answer 3

No hay absolutamente ninguna diferencia de rendimiento en este caso.

Como StartEngine no es virtual, el compilador, y más tarde el jitter, saben exactamente lo que significa una llamada, ya sea en la base, en la clase derivada o desde una clase externa.

Si StartEngine eran virtual, y el compilador y/o fluctuación puede deducir que la que está llamando con respecto a un CityBus en lugar de algo derivado de un CityBus, entonces lo que (muy pequeña) diferencia que hay podría también se eliminará como una optimización

Si StartEngine era virtual, y el compilador y/o la inestabilidad no pueden deducir si está llamando con respecto a un CityBus en lugar de una clase derivada, la distinción entre una llamada base o directa es vital para la corrección.

Como regla general, el único lugar para llamar a un método base con base. es una anulación de ese método, para hacer uso más claro. Si la distinción entre la versión base y la derivada es importante en cualquier otro lugar, entonces debe tratar de refactorizar para que base.SomeVirtualMethod() llame al base.SomeNonVirtual(), el cual está siempre disponible incluso cuando derived.SomeVirtualMethod() cambia el comportamiento.