Comment arrêter l'exécution d'une méthode, après un moment précis?

J'ai besoin d'arrêter l'exécution d'une méthode si elle n'est pas terminée à l'intérieur d'une période de temps limitée.

Pour faire ce travail, je peux utiliser les Thread.Abort méthode de cette façon:

void RunWithTimeout(ThreadStart entryPoint, int timeout)
{
    var thread = new Thread(() =>
    {
        try
        {
            entryPoint();
        }
        catch (ThreadAbortException)
        {   }

    }) { IsBackground = true };

    thread.Start();

    if (!thread.Join(timeout))
        thread.Abort();
}

Étant donné que je suis en utilisant .NET 3.5, est-il un meilleur moyen?

Edit: suite aux commentaires, voici mon entryPoint, mais je suis à la recherche d'un bon moyen pour tout entryPoint.

void entryPoint()
{
   //I can't use ReceiveTimeout property
   //there is not a ReceiveTimeout for the Compact Framework
   socket.Receive(...);
}
Voulez-vous lancer une ThnreadAbortException sans utiliser de Fil.Abandonner, ou voulez-vous arrêter l'exécution d'une méthode, après un délai d'attente?
la deuxième: arrêter l'exécution d'une méthode après un délai d'attente
stackoverflow.com/questions/299198/...
Envisagez l'utilisation d'une Tâche de la Bibliothèque Parallèle avec un CancellationToken.
La réponse est pire que ma solution...

OriginalL'auteur Nick | 2012-11-07

  1. 8

    Réponse dépend de "l'œuvre". Si le travail est quelque chose qui peut être arrêté en toute sécurité (pas des e/S opération de blocage) - utilisation Backgroundworker.CancelAsync(...)

    Si vous n'avez pas à couper dur je voudrais examiner à l'aide d'un Process, auquel cas le Aborting processus est plus propre - et process.WaitForExit(timeout) est votre ami.

    Suggéré TPL est grande, mais, malheureusement, n'existe pas .Net 3.5.

    EDIT: Vous pouvez utiliser Réactif Extensions à suivre Jan de Vaan la suggestion.

    Voici ma 'action timeout' snip - c'est principalement ici pour les autres de commenter:

        public static bool WaitforExit(this Action act, int timeout)
    {
        var cts = new CancellationTokenSource();
        var task = Task.Factory.StartNew(act, cts.Token);
        if (Task.WaitAny(new[] { task }, TimeSpan.FromMilliseconds(timeout)) < 0)
        { //timeout
            cts.Cancel();
            return false;
        }
        else if (task.Exception != null)
        { //exception
            cts.Cancel();
            throw task.Exception;
        }
        return true;
    }

    MODIFIER: Apparemment ce n'est pas exactement ce que l'OP voulait. Voici ma tentative de mettre au point un " annulable prise récepteur:

    public static class Ext
{
    public static object RunWithTimeout<T>(Func<T,object> act, int timeout, T obj) where T : IDisposable
    {
        object result = null;
        Thread thread = new Thread(() => { 
            try { result = act(obj); }
            catch {}    //this is where we end after timeout...
        });

        thread.Start();
        if (!thread.Join(timeout))
        {
            obj.Dispose();
            thread.Join();
        }
        return result;
    }       
}

class Test
{
    public void SocketTimeout(int timeout)
    {
        using (var sock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
        {
            Object res = Ext.RunWithTimeout(EntryPoint, timeout, sock);
        }
    }

    private object EntryPoint(Socket sock)
    {
        var buf = new byte[256];
        sock.Receive(buf);
        return buf;
    }
}
    CancelAsync ne fait pas les abandonner votre fil ou quelque chose comme ça. Il envoie un message à la thread de travail que le travail doit être annulé via BackgroundWorker.CancellationPending. Votre DoWork délégué qui est a couru dans le fond il faut vérifier périodiquement cette propriété et de gérer l'annulation elle-même. Donc, ce n'est pas ce que je neeed. La deuxième option (créer un processus) est une solution plus propre, mais nécessite beaucoup de ressources supplémentaires. Extension de réactif est bien pour le projet passe-temps, mais j'ai besoin d'une solution pour un projet commercial (je ne peux pas mettre à jour .NET 4.0). De toute façon +1, c'est une bonne réponse 🙂
    Yap. Peut-on voir le DoWork' ?
    Voir modifier, mais (comme je l'ai écrit), je préfère un bon moyen pour n'importe quel point d'entrée.
    En Évitant De Fil.Avorter est toujours une bonne idée. Pour l'éviter il sur un sujet que vous n'avez pas créé, c'est encore mieux. Comment Arrêter un Thread .NET (et Pourquoi Thread.Avorter est Mal) interagissent-sw.co.royaume-uni/iangblog/2004/11/12/annulation les Dangers de Fil.Abandonner par Eric Lippert blogs.msdn.com/b/ericlippert/archive/2010/02/22/...

    OriginalL'auteur

  2. 4

    Fil de discussion.Avorter est généralement une mauvaise solution. Vous devez utiliser un flag indiquant si l'opération est annulée et vérifier à l'intérieur de votre point d'entrée de la fonction.

     class Program
    {
        static void Main(string[] args)
        {
            RunWithTimeout((token) =>
                               {
                                   Thread.Sleep(2000);
                                   if (token.Cancel)
                                   {
                                       Console.WriteLine("Canceled");
                                   }
                               }, 1000);

            Console.ReadLine();
        }

        private class Token
        {
            public bool Cancel { get; set; }
        }

        static void RunWithTimeout(Action<Token> entryPoint, int timeout)
        {

            Token token = new Token();

            var thread = new Thread(() => entryPoint(token)) { IsBackground = true };

            thread.Start();

            if (!thread.Join(timeout))
                token.Cancel = true;
        }
    }
    Je ne peux pas vérifier la valeur du jeton.Annuler partout. Si j'ai besoin d'arrêter après 1 seconde, j'ai arrêter après 1 seconde, peu importe où je suis.
    Une autre solution est d'utiliser un processus enfant... mais c'est plus consommateur de ressources.

    OriginalL'auteur Andrei Schneider