1 using System; 2 using System.Collections.Generic; 3 using System.Windows.Input; 4 5 namespace WPF.Commands 6 { 7 /// <summary> 8 /// This class allows delegating the commanding logic to methods passed as parameters, 9 /// and enables a View to bind commands to objects that are not part of the element tree. 10 /// </summary> 11 public class DelegateCommand : ICommand 12 { 13 #region Constructors 14 15 /// <summary> 16 /// Constructor 17 /// </summary> 18 public DelegateCommand(Action executeMethod) 19 : this(executeMethod, null, false) 20 { 21 } 22 23 /// <summary> 24 /// Constructor 25 /// </summary> 26 public DelegateCommand(Action executeMethod, Func<bool> canExecuteMethod) 27 : this(executeMethod, canExecuteMethod, false) 28 { 29 } 30 31 /// <summary> 32 /// Constructor 33 /// </summary> 34 public DelegateCommand(Action executeMethod, Func<bool> canExecuteMethod, bool isAutomaticRequeryDisabled) 35 { 36 if (executeMethod == null) 37 { 38 throw new ArgumentNullException("executeMethod"); 39 } 40 41 _executeMethod = executeMethod; 42 _canExecuteMethod = canExecuteMethod; 43 _isAutomaticRequeryDisabled = isAutomaticRequeryDisabled; 44 } 45 46 #endregion 47 48 #region Public Methods 49 50 /// <summary> 51 /// Method to determine if the command can be executed 52 /// </summary> 53 public bool CanExecute() 54 { 55 if (_canExecuteMethod != null) 56 { 57 return _canExecuteMethod(); 58 } 59 return true; 60 } 61 62 /// <summary> 63 /// Execution of the command 64 /// </summary> 65 public void Execute() 66 { 67 if (_executeMethod != null) 68 { 69 _executeMethod(); 70 } 71 } 72 73 /// <summary> 74 /// Property to enable or disable CommandManager's automatic requery on this command 75 /// </summary> 76 public bool IsAutomaticRequeryDisabled 77 { 78 get 79 { 80 return _isAutomaticRequeryDisabled; 81 } 82 set 83 { 84 if (_isAutomaticRequeryDisabled != value) 85 { 86 if (value) 87 { 88 CommandManagerHelper.RemoveHandlersFromRequerySuggested(_canExecuteChangedHandlers); 89 } 90 else 91 { 92 CommandManagerHelper.AddHandlersToRequerySuggested(_canExecuteChangedHandlers); 93 } 94 _isAutomaticRequeryDisabled = value; 95 } 96 } 97 } 98 99 /// <summary> 100 /// Raises the CanExecuteChaged event 101 /// </summary> 102 public void RaiseCanExecuteChanged() 103 { 104 OnCanExecuteChanged(); 105 } 106 107 /// <summary> 108 /// Protected virtual method to raise CanExecuteChanged event 109 /// </summary> 110 protected virtual void OnCanExecuteChanged() 111 { 112 CommandManagerHelper.CallWeakReferenceHandlers(_canExecuteChangedHandlers); 113 } 114 115 #endregion 116 117 #region ICommand Members 118 119 /// <summary> 120 /// ICommand.CanExecuteChanged implementation 121 /// </summary> 122 public event EventHandler CanExecuteChanged 123 { 124 add 125 { 126 if (!_isAutomaticRequeryDisabled) 127 { 128 CommandManager.RequerySuggested += value; 129 } 130 CommandManagerHelper.AddWeakReferenceHandler(ref _canExecuteChangedHandlers, value, 2); 131 } 132 remove 133 { 134 if (!_isAutomaticRequeryDisabled) 135 { 136 CommandManager.RequerySuggested -= value; 137 } 138 CommandManagerHelper.RemoveWeakReferenceHandler(_canExecuteChangedHandlers, value); 139 } 140 } 141 142 /// <summary> 143 /// 144 /// </summary> 145 /// <param name="parameter"></param> 146 /// <returns></returns> 147 bool ICommand.CanExecute(object parameter) 148 { 149 return CanExecute(); 150 } 151 152 /// <summary> 153 /// 154 /// </summary> 155 /// <param name="parameter"></param> 156 void ICommand.Execute(object parameter) 157 { 158 Execute(); 159 } 160 161 #endregion 162 163 #region Data 164 /// <summary> 165 /// 166 /// </summary> 167 private readonly Action _executeMethod = null; 168 /// <summary> 169 /// 170 /// </summary> 171 private readonly Func<bool> _canExecuteMethod = null; 172 /// <summary> 173 /// 174 /// </summary> 175 private bool _isAutomaticRequeryDisabled = false; 176 /// <summary> 177 /// 178 /// </summary> 179 private List<WeakReference> _canExecuteChangedHandlers; 180 181 #endregion 182 } 183 184 /// <summary> 185 /// This class allows delegating the commanding logic to methods passed as parameters, 186 /// and enables a View to bind commands to objects that are not part of the element tree. 187 /// </summary> 188 /// <typeparam name="TExecuteParameter">Type of the parameter passed to the delegates</typeparam> 189 public class DelegateCommand<TExecuteParameter> : ICommand 190 { 191 #region Constructors 192 193 /// <summary> 194 /// Constructor 195 /// </summary> 196 public DelegateCommand(Action<TExecuteParameter> onExecute) 197 : this(onExecute, null, false) 198 { 199 } 200 201 /// <summary> 202 /// Constructor 203 /// </summary> 204 public DelegateCommand(Action<TExecuteParameter> onExecute, Func<TExecuteParameter, bool> canExecute) 205 : this(onExecute, canExecute, false) 206 { 207 } 208 209 /// <summary> 210 /// Constructor 211 /// </summary> 212 public DelegateCommand(Action<TExecuteParameter> onExecute, Func<TExecuteParameter, bool> canExecute, bool isAutomaticRequeryDisabled) 213 { 214 if (onExecute == null) 215 { 216 throw new ArgumentNullException("executeMethod"); 217 } 218 _onExecute = onExecute; 219 _canExecute = canExecute; 220 _isAutomaticRequeryDisabled = isAutomaticRequeryDisabled; 221 } 222 223 #endregion 224 225 #region Public Methods 226 227 /// <summary> 228 /// Method to determine if the command can be executed 229 /// </summary> 230 public bool CanExecute(TExecuteParameter parameter) 231 { 232 if (_canExecute != null) 233 { 234 return _canExecute(parameter); 235 } 236 return true; 237 } 238 239 /// <summary> 240 /// Execution of the command 241 /// </summary> 242 public void Execute(TExecuteParameter parameter) 243 { 244 if (_onExecute != null) 245 { 246 _onExecute(parameter); 247 } 248 } 249 250 /// <summary> 251 /// Raises the CanExecuteChaged event 252 /// </summary> 253 public void RaiseCanExecuteChanged() 254 { 255 OnCanExecuteChanged(); 256 } 257 258 /// <summary> 259 /// Protected virtual method to raise CanExecuteChanged event 260 /// </summary> 261 protected virtual void OnCanExecuteChanged() 262 { 263 CommandManagerHelper.CallWeakReferenceHandlers(_canExecuteChangedHandlers); 264 } 265 266 /// <summary> 267 /// Property to enable or disable CommandManager's automatic requery on this command 268 /// </summary> 269 public bool IsAutomaticRequeryDisabled 270 { 271 get 272 { 273 return _isAutomaticRequeryDisabled; 274 } 275 set 276 { 277 if (_isAutomaticRequeryDisabled != value) 278 { 279 if (value) 280 { 281 CommandManagerHelper.RemoveHandlersFromRequerySuggested(_canExecuteChangedHandlers); 282 } 283 else 284 { 285 CommandManagerHelper.AddHandlersToRequerySuggested(_canExecuteChangedHandlers); 286 } 287 _isAutomaticRequeryDisabled = value; 288 } 289 } 290 } 291 292 #endregion 293 294 #region ICommand Members 295 296 /// <summary> 297 /// ICommand.CanExecuteChanged implementation 298 /// </summary> 299 public event EventHandler CanExecuteChanged 300 { 301 add 302 { 303 if (!_isAutomaticRequeryDisabled) 304 { 305 CommandManager.RequerySuggested += value; 306 } 307 CommandManagerHelper.AddWeakReferenceHandler(ref _canExecuteChangedHandlers, value, 2); 308 } 309 remove 310 { 311 if (!_isAutomaticRequeryDisabled) 312 { 313 CommandManager.RequerySuggested -= value; 314 } 315 CommandManagerHelper.RemoveWeakReferenceHandler(_canExecuteChangedHandlers, value); 316 } 317 } 318 319 /// <summary> 320 /// 321 /// </summary> 322 /// <param name="parameter"></param> 323 /// <returns></returns> 324 bool ICommand.CanExecute(object parameter) 325 { 326 // if T is of value type and the parameter is not 327 // set yet, then return false if CanExecute delegate 328 // exists, else return true 329 var type = typeof(TExecuteParameter); 330 if (type.IsValueType && type.IsPrimitive) 331 { 332 if (int.TryParse(parameter.ToString(), out int intResult)) 333 { 334 return CanExecute((TExecuteParameter)(object)intResult); 335 } 336 } 337 338 if (parameter == null && type.IsValueType) 339 { 340 return (_canExecute == null); 341 } 342 return CanExecute((TExecuteParameter)parameter); 343 } 344 345 /// <summary> 346 /// 347 /// </summary> 348 /// <param name="parameter"></param> 349 void ICommand.Execute(object parameter) 350 { 351 Execute((TExecuteParameter)parameter); 352 } 353 354 #endregion 355 356 #region Data 357 /// <summary> 358 /// 359 /// </summary> 360 private readonly Action<TExecuteParameter> _onExecute = null; 361 /// <summary> 362 /// 363 /// </summary> 364 private readonly Func<TExecuteParameter, bool> _canExecute = null; 365 /// <summary> 366 /// 367 /// </summary> 368 private bool _isAutomaticRequeryDisabled = false; 369 /// <summary> 370 /// 371 /// </summary> 372 private List<WeakReference> _canExecuteChangedHandlers; 373 374 #endregion 375 } 376 377 /// <summary> 378 /// This class contains methods for the CommandManager that help avoid memory leaks by 379 /// using weak references. 380 /// </summary> 381 internal class CommandManagerHelper 382 { 383 internal static void CallWeakReferenceHandlers(List<WeakReference> handlers) 384 { 385 if (handlers != null) 386 { 387 // Take a snapshot of the handlers before we call out to them since the handlers 388 // could cause the array to me modified while we are reading it. 389 390 EventHandler[] callees = new EventHandler[handlers.Count]; 391 int count = 0; 392 393 for (int i = handlers.Count - 1; i >= 0; i--) 394 { 395 WeakReference reference = handlers[i]; 396 EventHandler handler = reference.Target as EventHandler; 397 if (handler == null) 398 { 399 // Clean up old handlers that have been collected 400 handlers.RemoveAt(i); 401 } 402 else 403 { 404 callees[count] = handler; 405 count++; 406 } 407 } 408 409 // Call the handlers that we snapshotted 410 for (int i = 0; i < count; i++) 411 { 412 EventHandler handler = callees[i]; 413 handler(null, EventArgs.Empty); 414 } 415 } 416 } 417 418 /// <summary> 419 /// 420 /// </summary> 421 /// <param name="handlers"></param> 422 internal static void AddHandlersToRequerySuggested(List<WeakReference> handlers) 423 { 424 if (handlers != null) 425 { 426 foreach (WeakReference handlerRef in handlers) 427 { 428 EventHandler handler = handlerRef.Target as EventHandler; 429 if (handler != null) 430 { 431 CommandManager.RequerySuggested += handler; 432 } 433 } 434 } 435 } 436 437 /// <summary> 438 /// 439 /// </summary> 440 /// <param name="handlers"></param> 441 internal static void RemoveHandlersFromRequerySuggested(List<WeakReference> handlers) 442 { 443 if (handlers != null) 444 { 445 foreach (WeakReference handlerRef in handlers) 446 { 447 EventHandler handler = handlerRef.Target as EventHandler; 448 if (handler != null) 449 { 450 CommandManager.RequerySuggested -= handler; 451 } 452 } 453 } 454 } 455 456 /// <summary> 457 /// 458 /// </summary> 459 /// <param name="handlers"></param> 460 /// <param name="handler"></param> 461 internal static void AddWeakReferenceHandler(ref List<WeakReference> handlers, EventHandler handler) 462 { 463 AddWeakReferenceHandler(ref handlers, handler, -1); 464 } 465 466 /// <summary> 467 /// 468 /// </summary> 469 /// <param name="handlers"></param> 470 /// <param name="handler"></param> 471 /// <param name="defaultListSize"></param> 472 internal static void AddWeakReferenceHandler(ref List<WeakReference> handlers, EventHandler handler, int defaultListSize) 473 { 474 if (handlers == null) 475 { 476 handlers = (defaultListSize > 0 ? new List<WeakReference>(defaultListSize) : new List<WeakReference>()); 477 } 478 479 handlers.Add(new WeakReference(handler)); 480 } 481 482 /// <summary> 483 /// 484 /// </summary> 485 /// <param name="handlers"></param> 486 /// <param name="handler"></param> 487 internal static void RemoveWeakReferenceHandler(List<WeakReference> handlers, EventHandler handler) 488 { 489 if (handlers != null) 490 { 491 for (int i = handlers.Count - 1; i >= 0; i--) 492 { 493 WeakReference reference = handlers[i]; 494 EventHandler existingHandler = reference.Target as EventHandler; 495 if ((existingHandler == null) || (existingHandler == handler)) 496 { 497 // Clean up old handlers that have been collected 498 // in addition to the handler that is to be removed. 499 handlers.RemoveAt(i); 500 } 501 } 502 } 503 } 504 } 505 }
1 <Button Width="60" 2 Height="30" 3 DataContext="{Binding RelativeSource={RelativeSource AncestorType=Window}}" 4 Command="{Binding TestCommand}" 5 CommandParameter="123">Test</Button>