Затримки викликів функцій

Чи є хороший простий метод затримки виклику функції, дозволяючи потоку продовжувати виконуватись?

напр

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
}

Я знаю, що цього можна досягти за допомогою таймера та обробників подій, але мені було цікаво, чи існує стандартний спосіб # # для досягнення цього?

Якщо комусь цікаво, причиною цього є те, що foo () і bar () знаходяться в різних (одиночних) класах, і мені потрібно телефонувати один одному у виняткових обставинах. Проблема полягає в тому, що це робиться при ініціалізації, тому foo повинен викликати bar, якому потрібен екземпляр створюваного класу foo ... отже, відкладений виклик bar (), щоб переконатися, що foo повністю інстанційований. майже присмаки поганого дизайну!

РЕДАГУВАТИ

Я зважатиму на думки щодо поганого дизайну! Я давно думав, що зможу вдосконалити систему, однак ця неприємна ситуація виникає лише тоді, коли створюється виняток, у будь-який інший час два синглони дуже добре співіснують. Я думаю, що я не збираюся спілкуватися з неприємними асинхронними скоромовками, скоріше, я буду рефакторизувати ініціалізацію одного з класів.

Завдяки сучасній C # 5/6 :)

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

public void bar()
{
    // do stuff
}

Я сам шукав щось подібне - я придумав наступне, хоча він використовує таймер, він використовує його лише один раз для початкової затримки і не вимагає жодних Sleepдзвінків ...

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
}

(подяка Фреду Дешену за ідею розпоряджатися таймером у зворотному дзвінку)

Окрім того, що я погодився з дизайнерськими спостереженнями попередніх коментаторів, жодне з рішень не було для мене досить чистим. .Net 4 забезпечує Dispatcherта Taskкласи, які роблять затримку виконання поточного потоку досить простою:

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 ();
    }
}

Для контексту, я використовую це, щоб розрізнити ICommandприв’язану до лівої кнопки миші вгору на елемент інтерфейсу. Користувачі подвійно клацають, що спричинило всілякі хаоси. (Я знаю, що я міг би також використовувати Click/ DoubleClickобробники, але я хотів рішення, яке працює з ICommands по всій платі).

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

        _execute ();
    }
}

Звучить, контроль над створенням обох цих об'єктів та їх взаємозалежність потрібно контролювати зовні, а не між самими класами.

Це справді дуже поганий дизайн, не кажучи вже про синглтон сам по собі поганий дизайн.

Однак якщо вам дійсно потрібно затримати виконання, ось що ви можете зробити:

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

Однак це буде викликано bar()в окремому потоці. Якщо вам потрібно зателефонувати bar()в початковий потік, можливо, вам доведеться перенести bar()виклик до RunWorkerCompletedобробника або трохи зламати SynchronizationContext.

Ну, я мав би погодитися з пунктом "проектування" ... але ви, мабуть, можете використовувати монітор, щоб повідомити одного, коли інший пройде критичний розділ ...

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

        }


    }

}

Використання:

DelayedDelegate.Add(MyMethod,5);

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

Я хоч ідеальним рішенням було б, щоб таймер обробляв відкладену дію. FxCop не любить, коли у вас інтервал менше однієї секунди. Мені потрібно відкласти свої дії, доки ПІСЛЯ мого DataGrid не завершить сортування за стовпцями. Я вважав, що рішенням буде одноразовий таймер (AutoReset = false), і він чудово працює. І, FxCop не дозволить мені придушити попередження!

Це буде працювати або на старих версіях .NET
Cons: буде виконуватися у власному потоці

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();

    }

Використання:

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

Існує не стандартний спосіб затримки виклику функції, окрім використання таймера та подій.

Це звучить як графічний інтерфейс затримки виклику методу, щоб ви могли бути впевнені, що форма закінчила викладати. Не гарна ідея.

Спираючись на відповідь Девіда О'Доног'ю, ось оптимізована версія Delayed Delegate:

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();
            }
        }
    }
}

Клас можна було б дещо покращити, використовуючи унікальний ключ для делегатів. Тому що, якщо ви додасте того самого делегата вдруге до того, як був запущений перший, у вас може виникнути проблема зі словником.

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