Geciken işlev çağrıları

İş parçacığının yürütülmeye devam etmesine izin verirken bir işlev çağrısını geciktirmenin güzel ve basit bir yöntemi var mı?

Örneğin

public void foo()
{
    // Do stuff!

    // Delayed call to bar() after x number of ms

    // Do more Stuff
}

public void bar()
{
    // Only execute once foo has finished
}

Bunun bir zamanlayıcı ve olay işleyicileri kullanılarak elde edilebileceğinin farkındayım, ancak bunu başarmanın standart bir c # yolu olup olmadığını merak ediyordum.

Meraklı biri varsa, bunun gerekli olmasının nedeni foo () ve bar () 'ın istisnai durumlarda birbirlerini çağırmam gereken farklı (tekli) sınıflarda olmasıdır. Sorun şu ki, bunun başlatmada yapılması, bu yüzden foo'nun, oluşturulan foo sınıfının bir örneğine ihtiyaç duyan bar'ı çağırması gerekiyor ... bu nedenle, foo'nun tam olarak yerleşik olmasını sağlamak için bar () 'a gecikmeli çağrı. neredeyse kötü tasarım kokusu!

DÜZENLE

Kötü tasarımla ilgili noktaları tavsiye altında alacağım! Uzun zamandır sistemi geliştirebileceğimi düşündüm, ancak bu kötü durum sadece bir istisna atıldığında ortaya çıkıyor, diğer tüm zamanlarda iki singleton çok güzel bir şekilde bir arada var oluyor. Kötü eşzamansız kalıplarla uğraşmayacağımı düşünüyorum, bunun yerine sınıflardan birinin ilklendirmesini yeniden düzenleyeceğim.

Modern C # 5/6 sayesinde :)

public void foo()
{
    Task.Delay(1000).ContinueWith(t=> bar());
}

public void bar()
{
    // do stuff
}

Ben de böyle bir şey arıyordum - aşağıdakini buldum, bir zamanlayıcı kullanmasına rağmen, ilk gecikme için yalnızca bir kez kullanıyor ve herhangi bir Sleeparama gerektirmiyor ...

public void foo()
{
    System.Threading.Timer timer = null; 
    timer = new System.Threading.Timer((obj) =>
                    {
                        bar();
                        timer.Dispose();
                    }, 
                null, 1000, System.Threading.Timeout.Infinite);
}

public void bar()
{
    // do stuff
}

(Geri aramada zamanlayıcıyı elden çıkarma fikri için Fred Deschenes'e teşekkürler )

Önceki yorumcuların tasarım gözlemlerine katılmanın yanı sıra, çözümlerin hiçbiri benim için yeterince temiz değildi. .Net 4 sağlar Dispatcherve Taskyürütme geciktirmek yapmak sınıflar geçerli iş parçacığı üzerinde oldukça basit:

static class AsyncUtils
{
    static public void DelayCall(int msec, Action fn)
    {
        // Grab the dispatcher from the current executing thread
        Dispatcher d = Dispatcher.CurrentDispatcher;

        // Tasks execute in a thread pool thread
        new Task (() => {
            System.Threading.Thread.Sleep (msec);   // delay

            // use the dispatcher to asynchronously invoke the action 
            // back on the original thread
            d.BeginInvoke (fn);                     
        }).Start ();
    }
}

Bağlam için, bunu ICommandbir UI öğesinde sol fare düğmesine bağlı bir düğmeyi iptal etmek için kullanıyorum . Kullanıcılar çift tıklıyor ve bu da her türlü hasara neden oluyordu. (Ayrıca Click/ DoubleClickişleyicileri de kullanabileceğimi biliyorum , ancak ICommandher yerde s ile çalışan bir çözüm istedim ).

public void Execute(object parameter)
{
    if (!IsDebouncing) {
        IsDebouncing = true;
        AsyncUtils.DelayCall (DebouncePeriodMsec, () => {
            IsDebouncing = false;
        });

        _execute ();
    }
}

Hem bu nesnelerin yaratılmasının kontrolü hem de karşılıklı bağımlılıklarının sınıflar arasında değil, dışarıdan kontrol edilmesi gerektiği gibi görünüyor.

Gerçekten de çok kötü bir tasarım, bırakın tek başına kötü tasarım.

Ancak, yürütmeyi gerçekten ertelemeniz gerekiyorsa, şunları yapabilirsiniz:

BackgroundWorker barInvoker = new BackgroundWorker();
barInvoker.DoWork += delegate
    {
        Thread.Sleep(TimeSpan.FromSeconds(1));
        bar();
    };
barInvoker.RunWorkerAsync();

Ancak bu, bar()ayrı bir iş parçacığı üzerinde başlatılacaktır. bar()Orijinal iş parçacığını aramanız gerekirse, bar()çağrıyı RunWorkerCompletedişleyiciye taşımanız veya biraz hacklemeniz gerekebilir SynchronizationContext.

Pekala, "tasarım" noktasına katılıyorum ... ama biri kritik bölümü geçtiğinde diğerini haberdar etmek için bir Monitör kullanabilirsiniz ...

    public void foo() {
        // Do stuff!

        object syncLock = new object();
        lock (syncLock) {
            // Delayed call to bar() after x number of ms
            ThreadPool.QueueUserWorkItem(delegate {
                lock(syncLock) {
                    bar();
                }
            });

            // Do more Stuff
        } 
        // lock now released, bar can begin            
    }

public static class DelayedDelegate
{

    static Timer runDelegates;
    static Dictionary<MethodInvoker, DateTime> delayedDelegates = new Dictionary<MethodInvoker, DateTime>();

    static DelayedDelegate()
    {

        runDelegates = new Timer();
        runDelegates.Interval = 250;
        runDelegates.Tick += RunDelegates;
        runDelegates.Enabled = true;

    }

    public static void Add(MethodInvoker method, int delay)
    {

        delayedDelegates.Add(method, DateTime.Now + TimeSpan.FromSeconds(delay));

    }

    static void RunDelegates(object sender, EventArgs e)
    {

        List<MethodInvoker> removeDelegates = new List<MethodInvoker>();

        foreach (MethodInvoker method in delayedDelegates.Keys)
        {

            if (DateTime.Now >= delayedDelegates[method])
            {
                method();
                removeDelegates.Add(method);
            }

        }

        foreach (MethodInvoker method in removeDelegates)
        {

            delayedDelegates.Remove(method);

        }


    }

}

Kullanım:

DelayedDelegate.Add(MyMethod,5);

void MyMethod()
{
     MessageBox.Show("5 Seconds Later!");
}

Bence mükemmel çözüm, gecikmeli eylemi bir zamanlayıcıya sahip olmaktır. FxCop, bir saniyeden daha kısa bir aralığınızın olmasından hoşlanmaz. DataGrid'im sütuna göre sıralamayı tamamladıktan SONRA eylemlerimi ertelemem gerekiyor. Tek seferlik bir zamanlayıcının (AutoReset = false) çözüm olacağını düşündüm ve mükemmel çalışıyor. VE, FxCop uyarıyı bastırmama izin vermiyor!

Bu, ya eski .NET
Eksileri sürümlerinde de çalışır : kendi iş parçacığında yürütülecektir

class CancelableDelay
    {
        Thread delayTh;
        Action action;
        int ms;

        public static CancelableDelay StartAfter(int milliseconds, Action action)
        {
            CancelableDelay result = new CancelableDelay() { ms = milliseconds };
            result.action = action;
            result.delayTh = new Thread(result.Delay);
            result.delayTh.Start();
            return result;
        }

        private CancelableDelay() { }

        void Delay()
        {
            try
            {
                Thread.Sleep(ms);
                action.Invoke();
            }
            catch (ThreadAbortException)
            { }
        }

        public void Cancel() => delayTh.Abort();

    }

Kullanım:

var job = CancelableDelay.StartAfter(1000, () => { WorkAfter1sec(); });  
job.Cancel(); //to cancel the delayed job

Zamanlayıcı ve olaylar kullanmak dışında bir işleve gelen çağrıyı geciktirmenin standart bir yolu yoktur.

Bu, bir yönteme yapılan bir çağrıyı geciktiren GUI karşıtı modele benziyor, böylece formun düzeninin tamamlandığından emin olabilirsiniz. İyi bir fikir değil.

David O'Donoghue'un cevabına dayanarak, Gecikmeli Delege'nin optimize edilmiş bir versiyonu:

using System.Windows.Forms;
using System.Collections.Generic;
using System;

namespace MyTool
{
    public class DelayedDelegate
    {
       static private DelayedDelegate _instance = null;

        private Timer _runDelegates = null;

        private Dictionary<MethodInvoker, DateTime> _delayedDelegates = new Dictionary<MethodInvoker, DateTime>();

        public DelayedDelegate()
        {
        }

        static private DelayedDelegate Instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new DelayedDelegate();
                }

                return _instance;
            }
        }

        public static void Add(MethodInvoker pMethod, int pDelay)
        {
            Instance.AddNewDelegate(pMethod, pDelay * 1000);
        }

        public static void AddMilliseconds(MethodInvoker pMethod, int pDelay)
        {
            Instance.AddNewDelegate(pMethod, pDelay);
        }

        private void AddNewDelegate(MethodInvoker pMethod, int pDelay)
        {
            if (_runDelegates == null)
            {
                _runDelegates = new Timer();
                _runDelegates.Tick += RunDelegates;
            }
            else
            {
                _runDelegates.Stop();
            }

            _delayedDelegates.Add(pMethod, DateTime.Now + TimeSpan.FromMilliseconds(pDelay));

            StartTimer();
        }

        private void StartTimer()
        {
            if (_delayedDelegates.Count > 0)
            {
                int delay = FindSoonestDelay();
                if (delay == 0)
                {
                    RunDelegates();
                }
                else
                {
                    _runDelegates.Interval = delay;
                    _runDelegates.Start();
                }
            }
        }

        private int FindSoonestDelay()
        {
            int soonest = int.MaxValue;
            TimeSpan remaining;

            foreach (MethodInvoker invoker in _delayedDelegates.Keys)
            {
                remaining = _delayedDelegates[invoker] - DateTime.Now;
                soonest = Math.Max(0, Math.Min(soonest, (int)remaining.TotalMilliseconds));
            }

            return soonest;
        }

        private void RunDelegates(object pSender = null, EventArgs pE = null)
        {
            try
            {
                _runDelegates.Stop();

                List<MethodInvoker> removeDelegates = new List<MethodInvoker>();

                foreach (MethodInvoker method in _delayedDelegates.Keys)
                {
                    if (DateTime.Now >= _delayedDelegates[method])
                    {
                        method();

                        removeDelegates.Add(method);
                    }
                }

                foreach (MethodInvoker method in removeDelegates)
                {
                    _delayedDelegates.Remove(method);
                }
            }
            catch (Exception ex)
            {
            }
            finally
            {
                StartTimer();
            }
        }
    }
}

Temsilciler için benzersiz bir anahtar kullanılarak sınıf biraz daha iyileştirilebilir. Çünkü aynı delegeyi, ilk atanmadan önce ikinci kez eklerseniz, sözlükle ilgili bir sorunla karşılaşabilirsiniz.

private static volatile List<System.Threading.Timer> _timers = new List<System.Threading.Timer>();
        private static object lockobj = new object();
        public static void SetTimeout(Action action, int delayInMilliseconds)
        {
            System.Threading.Timer timer = null;
            var cb = new System.Threading.TimerCallback((state) =>
            {
                lock (lockobj)
                    _timers.Remove(timer);
                timer.Dispose();
                action()
            });
            lock (lockobj)
                _timers.Add(timer = new System.Threading.Timer(cb, null, delayInMilliseconds, System.Threading.Timeout.Infinite));
}