Comment appeler manuellement un événement?

Peut-il être fait à l'aide de la traditionnelle C#? Aucun (comme indiqué précédemment). Mais l'utilisation de la réflexion, c'est possible. Voici quelques testé le code basé sur la réponse à ce forum MSDN fil:

class InvokeFromMe
{
    public event EventHandler RaiseMe;
}

class Program
{
    static void Main(string[] args)
    {
        var fromMe = new InvokeFromMe();

        fromMe.RaiseMe += fromMe_RaiseMe;
        fromMe.RaiseMe += fromMe_RaiseMe1;
        fromMe.RaiseMe += fromMe_RaiseMe2;

        FireEvent(fromMe, "RaiseMe", null, EventArgs.Empty);
    }

    static void fromMe_RaiseMe(object sender, EventArgs e)
    {
        Console.WriteLine("Event Handler 0 Raised");
    }
    static void fromMe_RaiseMe1(object sender, EventArgs e)
    {
        Console.WriteLine("Event Handler 1 Raised");
    }
    static void fromMe_RaiseMe2(object sender, EventArgs e)
    {
        Console.WriteLine("Event Handler 2 Raised");
    }

    public static void FireEvent(object onMe, string invokeMe, params object[] eventParams)
    {
        MulticastDelegate eventDelagate =
              (MulticastDelegate)onMe.GetType().GetField(invokeMe,
               System.Reflection.BindingFlags.Instance |
               System.Reflection.BindingFlags.NonPublic).GetValue(onMe);

        Delegate[] delegates = eventDelagate.GetInvocationList();

        foreach (Delegate dlg in delegates)
        {
            dlg.Method.Invoke(dlg.Target, eventParams);
        }
    } 

}

Mise à JOUR

Je ne suis pas familier avec le System.Timer.Timer classe, donc je ne suis pas sûr de ce qui est différent de mon exemple fourni. Vous pourriez peut-être essayer quelque chose comme:

public static void FirePublicEvent(object onMe, string invokeMe, params object[] eventParams)
{
    MulticastDelegate eventDelagate =
          (MulticastDelegate)onMe.GetType().GetField(invokeMe,
           System.Reflection.BindingFlags.Instance |
           System.Reflection.BindingFlags.Public).GetValue(onMe);

    Delegate[] delegates = eventDelagate.GetInvocationList();

    foreach (Delegate dlg in delegates)
    {
       dlg.Method.Invoke(dlg.Target, eventParams);
    }
} 

C'est un travail autour de vous, vous ne pouvez pas faire une boucle par l'événement Écoulée. Mais à les invoquer à tout, laisse le temps faire le travail. Ce code pour le Système.Minuteur, pas sûr de la minuterie que vous utilisez.

De présumer de la minuterie est déjà activé:

int interval = timer.Interval;
ElapsedEventHandler handler = null;
handler = (s,e) =>
{
    timer.Interval = interval; //put interval back to original value
    timer.Elapsed -= handler;
};
timer.Elapsed += handler;
timer.Interval = 1; //1 millisecond, pretty much going to fire right now (as soon as you let it)

Quelque chose comme qui va déclencher les événements, mais l'original de votre intervalle sera redémarré. Vous pourriez avoir à faire quelques calculs en y si vous voulez garder l'original tique modèle.

Je pense que vous avez probablement besoin d'utiliser InvokeMember:

public void GetMethod(string methodName){

            var args = new Object[] { [INSERT ARGS IF NECESSARY--SET TO NULL OTHERWISE] };
            try
            {
                var t = new [INSERT NAME OF CLASS THAT CONTAINS YOUR METHOD]();
                Type typeInfo = t.GetType();
                var result = typeInfo.InvokeMember(methodName, BindingFlags.InvokeMethod, null, t, args);
                return result;
            }
            catch (Exception ex)
            {
                return ex;
            }
}

Puis l'appeler comme ceci:

_timer.ElapsedTick += GetMethod("[INSERT METHOD NAME AS STRING]");

Assurez-vous d'inclure ceci:

using System.Reflection;

Bonne Chance!

bien je termine ici sur la recherche de la façon de simplement de début de l'événement, qui est de ne pas avoir tous les arguments ou quoi que ce soit. Je sais OP question, c'est différent! mais j'ai eu l'aime partager, j'espère que cela aide quelqu'un.

Unsimplify version:

 var Handler = EventNameHere;
        if (Handler != null)
        {
            Handler(this, EventArgs.Empty);
        }

Simplifier version:

 EventNameHere?.Invoke(this, EventArgs.Empty);

Vous pouvez uniquement appeler les événements de l'intérieur de la classe qui le déclare. Si vous avez écrit la classe timer, vous l'appeler comme ceci:

this.ElapsedTick(this, eventArgs);

À l'extérieur de la classe timer vous pouvez faire comme suit pour obtenir un comportement similaire:

delegate void delegateSample(object sender, EventArgs e);

delegateSample d;
d += new delegateSample(_somefunction1);
d += new delegateSample(_somefunction2);
d(this, EventArgs.Empty);

delegateSample devrait effectivement être le type de la ElapsedTick événement, au lieu de déclarer un autre type de délégué. Je ne savais pas le nom de ce délégué. Assurez-vous juste d'ajouter chaque fonction de la ElapsedTick événement et le délégué variable que vous déclarez ensuite, vous pouvez les appeler tous par le délégué à l'extérieur de la classe Timer.