/// <summary> /// Filtered invokes make sure only one instance of the given method call is in action at the given moment. /// This is usefull for calls that are made very many times, but we wish to allow the control to only /// process as much as it can in real time (not delaying any calls for later). /// Filtering is done on a method AND instance basis, so if you have 2 instances of same class alive, /// they will not interupt each others calls and each of them will receive what is due. /// </summary> /// <param name="minimumInterInvocationInterval">The interval between two consecutive invokes of the method; pass null for default; TimeSpan.Zero for immediate (based on a 100ms timer, so delay up to 100ms).</param> /// <returns>Result shows if the given invoke was placed, or if there is another one pending executing and this one was dropped.</returns> public static bool BeginFilteredManagedInvoke(Control control, TimeSpan minimumInterInvocationInterval, Delegate d, params object[] args) { MethodInvocationInformation information = null; // Obtain the corresponding invocation information item. lock (_filteredInvokes) { if (_filteredInvokes.ContainsKey(control) == false) { _filteredInvokes.Add(control, new Dictionary <MethodInfo, MethodInvocationInformation>()); } Dictionary <MethodInfo, MethodInvocationInformation> dictionary = _filteredInvokes[control]; if (dictionary.ContainsKey(d.Method) == false) { information = new MethodInvocationInformation(control, d); dictionary.Add(d.Method, information); } else { information = dictionary[d.Method]; } } return(information.Invoke(minimumInterInvocationInterval, args)); }
/// <summary> /// Filtered invokes make sure only one instance of the given method call is in action at the given moment. /// This is usefull for calls that are made very many times, but we wish to allow the control to only /// process as much as it can in real time (not delaying any calls for later). /// Filtering is done on a method AND instance basis, so if you have 2 instances of same class alive, /// they will not interupt each others calls and each of them will receive what is due. /// </summary> /// <param name="minimumInterInvocationInterval">The interval between two consecutive invokes of the method; pass null for default; TimeSpan.Zero for immediate (based on a 100ms timer, so delay up to 100ms).</param> /// <returns>Result shows if the given invoke was placed, or if there is another one pending executing and this one was dropped.</returns> public static bool BeginFilteredManagedInvoke(Control control, TimeSpan minimumInterInvocationInterval, Delegate d, params object[] args) { MethodInvocationInformation information = null; // Obtain the corresponding invocation information item. lock (_filteredInvokes) { if (_filteredInvokes.ContainsKey(control) == false) { _filteredInvokes.Add(control, new Dictionary<MethodInfo, MethodInvocationInformation>()); } Dictionary<MethodInfo, MethodInvocationInformation> dictionary = _filteredInvokes[control]; if (dictionary.ContainsKey(d.Method) == false) { information = new MethodInvocationInformation(control, d); dictionary.Add(d.Method, information); } else { information = dictionary[d.Method]; } } return information.Invoke(minimumInterInvocationInterval, args); }