studio - Nombrar eventos y manejadores de C#correctamente

que son eventos en c#

Question

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

En las dos clases a continuación, ¿alguien puede decirme si tengo el nombre correcto para el evento, el método que genera el evento y el método que controla 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 suscriptor:

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 por adelantado!

Answer 1

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

Dicho esto, los estándares de Microsoft son buenos si comparte su código con otros.

Normalmente, tendrías 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 método de activación del evento se nombra con el prefijo ''On''. El método de activación del evento también está protected virtual manera protected virtual modo que las clases derivadas pueden anular el cambio / adición al comportamiento, así como usarlo para disparar el evento cuando sea necesario.

Answer 2

Casi

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

por ejemplo, OnClosing , OnSomethigHasHappened , OnSomethigHasHappened

El evento <When>Event (de OnSomethingHasHappened )

es decir, antes de BeforeOpen , Closing , SomethingHasHappened BeforeOpen

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

es decir, Form_BeforeOpen , Window_Closing , Car_SomethingHasHappened -> perfect

Answer 3

Tiendo a hacer lo contrario:

public event EventHandler SomethingHappened;
private void OnSomethingHappened()
{
SomethingHappened();
}

Entonces:

private void Car_SomethingHappened()
{
}

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

private void SomethingHappenedHandler() {}

Answer 4

Yo diría que la convención de nomenclatura está bien, pero lo que echo de menos en su ejemplo, ¿QUÉ pasó?

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

Answer 5

Yo personalmente miro cómo Microsoft ha nombrado a sus eventos y cómo nombran a sus manejadores.

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