Nombrar correctamente los eventos y controladores de C#

Question

Por lo que he leído, no estoy seguro si tengo la convención de nomenclatura para eventos y manejadores correcta. (Parece que hay algunos consejos conflictivos por ahí).

En las dos clases a continuación ¿alguien puede decirme si tengo el nombre correcto para el evento, el método que plantea el evento y el método que maneja el evento?

public class Car 
{ 
// is event named correctly? 
public event EventHandler<EventArgs> OnSomethingHasHappened; 

private void MoveForward() 
{ 
    RaiseSomethingHasHappened(); 
} 

// is the named correctly 
private void RaiseSomethingHasHappened() 
{ 
    if(OnSomethingHasHappened != null) 
    { 
    OnSomethingHasHappened(this, new EventArgs()); 
    } 
} 
} 

y la clase de suscriptores:

public class Subscriber() 
{ 
public Subscriber() 
{ 
    Car car = new Car(); 
    car.OnSomethingHasHappened += Car_SomethingHasHappened(); 
} 

// is this named correctly? 
private void Car_SomethingHasHappened(object sender, EventArgs e) 
{ 
    // do stuff 
} 
} 

Gracias de antemano!

Answer 1

Personalmente miro cómo Microsoft ha nombrado sus eventos y cómo nombran a sus controladores.

class Form{ 
    public event EventHandler<EventArgs> MouseMove; 
    public virtual void OnMouseMove() 
    { 
     if(MouseMove != null) 
     { 
      MouseMove(this, new EventArgs()); 
     } 
    } 
} 

class Application{ 
    public Application() 
    { 
     Form form = new Form(); 
     form.MouseMove += //Hook your own Method 
    } 
} 

Answer 2

que tienden a hacer lo contrario:

public event EventHandler SomethingHappened; 

private void OnSomethingHappened() 
{ 
    SomethingHappened(); 
} 

continuación:

private void Car_SomethingHappened() 
{ 

} 

No es el código más limpio, pero la denominación es cómo lo hago. Si no hay un nombre de variable local clara o que no tiene sentido, que el sufijo con el nombre "Handler":

private void SomethingHappenedHandler() {} 

Answer 3

Casi

El método para desencadenar el evento - On<When>Event (de RaiseSomethingHasHappened)

es decir OnBeforeOpen, OnClosing, OnSomethigHasHappened

El evento <When>Event (de OnSomethingHasHappened)

es decir BeforeOpen, Closing, SomethingHasHappened

el manejador <The Instance or meaningful Name><_><Event> (de Car_SomethingHasHappened)

es decir Form_BeforeOpen, Window_Closing, Car_SomethingHasHappened -> perfecta

Answer 4

Yo diría que la convención de nombres está bien, pero lo que extraño en tu ejemplo ¿QUÉ paso?

Así que me gustaría especializarse más el nombre del evento en sí (como MovedForward) o si necesita más generalizada que debe proporcionar alguna información adicional dentro de los EventArgs sobre lo que ha cambiado (como el ListChanged en BindingList).

Answer 5

Bueno, el primer punto es que definas tu propia convención de nomenclatura y no hay una manera "incorrecta" de hacerlo (siempre que sea consistente).

Habiendo dicho eso, los estándares de Microsoft son buenos si comparte su código con otros.

Normalmente, usted tendría nombres de eventos como:

public class Car 
{ 
// is event named correctly? 
public event EventHandler<EventArgs> SomethingHasHappened; 

private void MoveForward() 
{ 
    OnSomethingHasHappened(); 
} 

// is the named correctly 
protected virtual void OnSomethingHasHappened() 
{ 
    EventHandler<EventArgs> locum = SomethingHasHappened; 
    if(locum!= null) 
    { 
    locum(this, new EventArgs()); 
    } 
} 
} 

Tenga en cuenta que el evento se titula sin el prefijo 'On', y el evento método de cocción es llamada con el prefijo 'On'. El método de activación de eventos también es protected virtual, de modo que las clases derivadas pueden anular para cambiar/agregar el comportamiento, así como usarlo para activar el evento cuando sea necesario.