Các cuộc gọi chức năng bị trì hoãn

Có một phương pháp đơn giản hay ho nào để trì hoãn một cuộc gọi hàm trong khi vẫn cho phép luồng tiếp tục thực thi không?

ví dụ

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
}

Tôi biết rằng có thể đạt được điều này bằng cách sử dụng bộ hẹn giờ và trình xử lý sự kiện, nhưng tôi tự hỏi liệu có cách c # tiêu chuẩn nào để đạt được điều này không?

Nếu ai đó tò mò, lý do yêu cầu điều này là foo () và bar () nằm trong các lớp (singleton) khác nhau mà tôi cần phải gọi nhau trong những trường hợp đặc biệt. Vấn đề là điều này được thực hiện khi khởi tạo vì vậy foo cần gọi thanh cần một thể hiện của lớp foo đang được tạo ... do đó, lệnh gọi đến bar () bị trì hoãn để đảm bảo rằng foo được cài đặt hoàn toàn .. Đọc lại phần này gần như thiết kế xấu!

BIÊN TẬP

Tôi sẽ đưa ra những điểm về thiết kế xấu theo lời khuyên! Từ lâu, tôi đã nghĩ rằng mình có thể cải thiện hệ thống, tuy nhiên, tình huống khó chịu này chỉ xảy ra khi một ngoại lệ được ném ra, ở những thời điểm khác, hai singleleton cùng tồn tại rất độc đáo. Tôi nghĩ rằng tôi sẽ không gặp rắc rối với những người bảo vệ không đồng bộ khó chịu, thay vào đó tôi sẽ cấu trúc lại quá trình khởi tạo của một trong các lớp.

Cảm ơn C # 5/6 hiện đại :)

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

public void bar()
{
    // do stuff
}

Tôi đã tự mình tìm kiếm một thứ như thế này - tôi đã nghĩ ra điều sau, mặc dù nó sử dụng bộ hẹn giờ, nó chỉ sử dụng một lần cho độ trễ ban đầu và không yêu cầu bất kỳ Sleepcuộc gọi nào ...

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
}

(cảm ơn Fred Deschenes vì ý tưởng sắp xếp bộ đếm thời gian trong cuộc gọi lại)

Ngoài việc đồng ý với quan sát thiết kế của những người bình luận trước đó, không có giải pháp nào đủ sạch đối với tôi. .Net 4 cung cấp Dispatchervà Taskcác lớp làm cho việc trì hoãn thực thi trên luồng hiện tại khá đơn giản:

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

Đối với ngữ cảnh, tôi đang sử dụng điều này để loại bỏ sự ICommandràng buộc với nút chuột trái trên một phần tử giao diện người dùng. Người dùng đang nhấp đúp vào điều này đã gây ra tất cả các loại tàn phá. (Tôi biết tôi cũng có thể sử dụng Click/ DoubleClicktrình xử lý, nhưng tôi muốn có một giải pháp hoạt động với ICommands trên toàn diện).

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

        _execute ();
    }
}

Nghe có vẻ như việc kiểm soát việc tạo ra cả hai đối tượng này và sự phụ thuộc lẫn nhau của chúng cần được kiểm soát từ bên ngoài, thay vì giữa chính các lớp.

Nó thực sự là một thiết kế rất tệ, hãy để singleton tự nó là một thiết kế tồi.

Tuy nhiên, nếu bạn thực sự cần trì hoãn việc thực thi, đây là những gì bạn có thể làm:

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

Tuy nhiên, điều này sẽ gọi bar()trên một chuỗi riêng biệt. Nếu bạn cần gọi bar()trong chuỗi ban đầu, bạn có thể cần chuyển bar()lời gọi sang RunWorkerCompletedtrình xử lý hoặc thực hiện một chút hack với SynchronizationContext.

Chà, tôi phải đồng ý với quan điểm "thiết kế" ... nhưng bạn có thể sử dụng Màn hình để cho một người biết khi người kia đã qua phần quan trọng ...

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

        }


    }

}

Sử dụng:

DelayedDelegate.Add(MyMethod,5);

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

Tôi mặc dù giải pháp hoàn hảo sẽ là có một bộ đếm thời gian xử lý hành động bị trì hoãn. FxCop không thích khi bạn có khoảng thời gian ít hơn một giây. Tôi cần trì hoãn hành động của mình cho đến khi SAU KHI DataGrid của tôi hoàn thành việc sắp xếp theo cột. Tôi đã tìm ra bộ hẹn giờ một lần chụp (AutoReset = false) sẽ là giải pháp và nó hoạt động hoàn hảo. VÀ, FxCop sẽ không cho phép tôi ngừng cảnh báo!

Điều này sẽ hoạt động trên các phiên bản cũ hơn của .NET
Nhược điểm: sẽ thực thi trong chuỗi của riêng nó

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

    }

Sử dụng:

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

Không có cách tiêu chuẩn nào để trì hoãn cuộc gọi đến một chức năng ngoài việc sử dụng bộ đếm thời gian và sự kiện.

Điều này có vẻ giống như kiểu chống trì hoãn lệnh gọi đến một phương thức của GUI để bạn có thể chắc chắn rằng biểu mẫu đã hoàn tất việc đặt. Không phải là một ý tưởng tốt.

Dựa trên câu trả lời từ David O'Donoghue, đây là phiên bản được tối ưu hóa của 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();
            }
        }
    }
}

Lớp có thể được cải thiện hơn một chút bằng cách sử dụng một khóa duy nhất cho các đại biểu. Bởi vì nếu bạn thêm cùng một đại biểu lần thứ hai trước khi người đầu tiên kích hoạt, bạn có thể gặp sự cố với từ điển.

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