WPF开发时光之痕日记本（二）—— WVVM基类

当我们用MVVM的时候要实现INotifyPropertyChanged,每次都要实现这个接口比较麻烦，所以基类的作用就体现出来了。代码如下：

    public class ViewModelBase : INotifyPropertyChanged, IDisposable
    {
        public event PropertyChangedEventHandler PropertyChanged;
        public bool IsInDesignMode;
        /// <summary> 显示名称 </summary>
        public virtual string DisplayName { get; protected set; }

        #region 构造

        public ViewModelBase()
        {

        }
        #endregion

        private void OnPropertyChanged(string propertyName)
        {
            if (this.PropertyChanged != null)
            {
                this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }
        private static string GetProperyName(string methodName)
        {
            if (methodName.StartsWith("get_") || methodName.StartsWith("set_") ||
                methodName.StartsWith("put_"))
            {
                return methodName.Substring(4);
            }
            throw new Exception(methodName + " not a method of Property");
        }

        protected void SetProperty<T>(ref T name, T value)
        {
            if (object.Equals(name, value)) return;
            name = value;
            string propertyName = GetProperyName(new System.Diagnostics.StackTrace(true).GetFrame(1).GetMethod().Name);
            this.OnPropertyChanged(propertyName);
        }

        #region IDisposable Members
        public void Dispose()
        {
            this.OnDispose();
        }
        /// <summary>
        /// 若支持IDisposable，请重写此方法，当被调用Dispose时会执行此方法。
        /// </summary>
        protected virtual void OnDispose()
        {
        }
        #endregion
    }
    public class CommandBase : System.Windows.Input.ICommand
    {
        private Action<Object> _doWork;
        private readonly Func<object, bool> _canExecute;

        /// <summary>
        /// 实例化一个CommandBase对象
        /// </summary>
        /// <param name="doWork">委托一个有object类型参数的命令执行函数</param>
        /// <param name="canExecute">委托一个有object类型参数的命令是否能被执行的函数（可选）</param>
        /// <exception cref="ArgumentNullException">参数command不可以为null引用</exception>
        public CommandBase(Action<object> doWork, Func<object, bool> canExecute = null)
        {
            if (doWork == null)
                throw new ArgumentNullException("doWork");

            _canExecute = canExecute;
            _doWork = doWork;
        }
        public bool CanExecute(Object parameter)
        {
            return true;
        }
        public void Execute(Object parameter)
        {
            if (this._doWork != null)
                this._doWork(parameter);
        }
        public event EventHandler CanExecuteChanged
        {
            add { }
            remove { }
        }
    }

　　使用方式如下，例：

 public class TestViewModel : ViewModelBase
    {
        public TestViewModel()
        {
            this.LoadCommand = new CommandBase((Object parameter) => Loading());
        }
        #region 属性

        private string _name;

        /// <summary> 是否可用 </summary>
        public string IsEnable
        {
            get { return _name; }
            set
            {
                base.SetProperty<string>(ref this._name, value);
            }
        }
        #endregion

        #region 命令

        /// <summary>
        /// 窗口加载命令
        /// </summary>
        public ICommand LoadCommand { get; set; }
        #endregion

        #region 方法

        /// <summary>
        /// 初始化方法
        /// </summary>
        public void Loading()
        {

        }
        #endregion
    }

　　看了例子后，是不是感觉很简单呢？详细的测试代码会再后续的文章中提供给大家参考。