创建WPF应用程序
基于生产这里选择.Net Framework进行开发
添加控件
由于不熟悉 高效点 我们这里直接拖拽控件
- 如果你有一点前端基础 你可以在控件对应Code 根据属性 对控件进行设置 包括颜色 大小 填充内容等
- 如果你对属性不是很熟悉 简单点 直接点控件双击本文--修改控件展示文本 双击控件--为控件添加双击事件
创建ViewModel【VM】
- 你的VM需要与前端控件绑定 并在有变更时 通知前端 所以你要实现 INotifyPropertyChanged接口
- 同时 将控件双击执行的事件 通过Command来绑定
所以这里我们直接封装一个ViewModelBase【拷贝直接可用 具体代码你可以选择不看】 你只需要让你的VM集成这个base 上诉两个功能点就可以直接调用了
public abstract class ViewModelBase : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
#region Methods
protected void RasePropertyChanged(string propertyName)
{
var handler = PropertyChanged;
handler?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
protected bool SetProperty<T>(ref T storage, T value, [CallerMemberName] string propertyName = null)
{
if (Equals(storage, value))
return false;
storage = value;
OnPropertyChanged(propertyName);
return true;
}
protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
#endregion Methods
#region Constructor
protected ViewModelBase()
{
}
#endregion Constructor
}
#region RelayCommand
public class RelayCommand : ICommand
{
private readonly WeakAction _execute;
private readonly WeakFunc<bool> _canExecute;
public event EventHandler CanExecuteChanged;
public RelayCommand(Action execute, bool keepTargetAlive = false)
: this(execute, null, keepTargetAlive)
{
}
public RelayCommand(Action execute, Func<bool> canExecute, bool keepTargetAlive = false)
{
if (execute == null)
{
throw new ArgumentNullException("execute");
}
_execute = new WeakAction(execute, keepTargetAlive);
if (canExecute != null)
{
_canExecute = new WeakFunc<bool>(canExecute, keepTargetAlive);
}
}
public void RaiseCanExecuteChanged()
{
this.CanExecuteChanged?.Invoke(this, EventArgs.Empty);
}
public bool CanExecute(object parameter)
{
if (_canExecute != null)
{
if (_canExecute.IsStatic || _canExecute.IsAlive)
{
return _canExecute.Execute();
}
return false;
}
return true;
}
public virtual void Execute(object parameter)
{
if (CanExecute(parameter) && _execute != null && (_execute.IsStatic || _execute.IsAlive))
{
_execute.Execute();
}
}
}
public class RelayCommand<T> : ICommand
{
private readonly WeakAction<T> _execute;
private readonly WeakFunc<T, bool> _canExecute;
public event EventHandler CanExecuteChanged;
public RelayCommand(Action<T> execute, bool keepTargetAlive = false)
: this(execute, (Func<T, bool>)null, keepTargetAlive)
{
}
public RelayCommand(Action<T> execute, Func<T, bool> canExecute, bool keepTargetAlive = false)
{
if (execute == null)
{
throw new ArgumentNullException("execute");
}
_execute = new WeakAction<T>(execute, keepTargetAlive);
if (canExecute != null)
{
_canExecute = new WeakFunc<T, bool>(canExecute, keepTargetAlive);
}
}
public void RaiseCanExecuteChanged()
{
this.CanExecuteChanged?.Invoke(this, EventArgs.Empty);
}
public bool CanExecute(object parameter)
{
if (_canExecute == null)
{
return true;
}
if (_canExecute.IsStatic || _canExecute.IsAlive)
{
if (parameter == null && typeof(T).GetTypeInfo().IsValueType)
{
return _canExecute.Execute(default(T));
}
if (parameter == null || parameter is T)
{
return _canExecute.Execute((T)parameter);
}
}
return false;
}
public virtual void Execute(object parameter)
{
if (!CanExecute(parameter) || _execute == null || (!_execute.IsStatic && !_execute.IsAlive))
{
return;
}
if (parameter == null)
{
if (typeof(T).GetTypeInfo().IsValueType)
{
_execute.Execute(default(T));
}
else
{
_execute.Execute((T)parameter);
}
}
else
{
_execute.Execute((T)parameter);
}
}
}
public class WeakFunc<TResult>
{
private Func<TResult> _staticFunc;
protected MethodInfo Method
{
get;
set;
}
public bool IsStatic => _staticFunc != null;
public virtual string MethodName
{
get
{
if (_staticFunc != null)
{
return _staticFunc.GetMethodInfo().Name;
}
return Method.Name;
}
}
protected WeakReference FuncReference
{
get;
set;
}
protected object LiveReference
{
get;
set;
}
protected WeakReference Reference
{
get;
set;
}
public virtual bool IsAlive
{
get
{
if (_staticFunc == null && Reference == null && LiveReference == null)
{
return false;
}
if (_staticFunc != null)
{
if (Reference != null)
{
return Reference.IsAlive;
}
return true;
}
if (LiveReference != null)
{
return true;
}
if (Reference != null)
{
return Reference.IsAlive;
}
return false;
}
}
public object Target
{
get
{
if (Reference == null)
{
return null;
}
return Reference.Target;
}
}
protected object FuncTarget
{
get
{
if (LiveReference != null)
{
return LiveReference;
}
if (FuncReference == null)
{
return null;
}
return FuncReference.Target;
}
}
protected WeakFunc()
{
}
public WeakFunc(Func<TResult> func, bool keepTargetAlive = false)
: this(func?.Target, func, keepTargetAlive)
{
}
public WeakFunc(object target, Func<TResult> func, bool keepTargetAlive = false)
{
if (func.GetMethodInfo().IsStatic)
{
_staticFunc = func;
if (target != null)
{
Reference = new WeakReference(target);
}
}
else
{
Method = func.GetMethodInfo();
FuncReference = new WeakReference(func.Target);
LiveReference = (keepTargetAlive ? func.Target : null);
Reference = new WeakReference(target);
}
}
public TResult Execute()
{
if (_staticFunc != null)
{
return _staticFunc();
}
object funcTarget = FuncTarget;
if (IsAlive && (object)Method != null && (LiveReference != null || FuncReference != null) && funcTarget != null)
{
return (TResult)Method.Invoke(funcTarget, null);
}
return default(TResult);
}
public void MarkForDeletion()
{
Reference = null;
FuncReference = null;
LiveReference = null;
Method = null;
_staticFunc = null;
}
}
public class WeakFunc<T, TResult> : WeakFunc<TResult>, IExecuteWithObjectAndResult
{
private Func<T, TResult> _staticFunc;
public override string MethodName
{
get
{
if (_staticFunc != null)
{
return _staticFunc.GetMethodInfo().Name;
}
return base.Method.Name;
}
}
public override bool IsAlive
{
get
{
if (_staticFunc == null && base.Reference == null)
{
return false;
}
if (_staticFunc != null)
{
if (base.Reference != null)
{
return base.Reference.IsAlive;
}
return true;
}
return base.Reference.IsAlive;
}
}
public WeakFunc(Func<T, TResult> func, bool keepTargetAlive = false)
: this(func?.Target, func, keepTargetAlive)
{
}
public WeakFunc(object target, Func<T, TResult> func, bool keepTargetAlive = false)
{
if (func.GetMethodInfo().IsStatic)
{
_staticFunc = func;
if (target != null)
{
base.Reference = new WeakReference(target);
}
}
else
{
base.Method = func.GetMethodInfo();
base.FuncReference = new WeakReference(func.Target);
base.LiveReference = (keepTargetAlive ? func.Target : null);
base.Reference = new WeakReference(target);
}
}
public new TResult Execute()
{
return Execute(default(T));
}
public TResult Execute(T parameter)
{
if (_staticFunc != null)
{
return _staticFunc(parameter);
}
object funcTarget = base.FuncTarget;
if (IsAlive && (object)base.Method != null && (base.LiveReference != null || base.FuncReference != null) && funcTarget != null)
{
return (TResult)base.Method.Invoke(funcTarget, new object[1]
{
parameter
});
}
return default(TResult);
}
public object ExecuteWithObject(object parameter)
{
T parameter2 = (T)parameter;
return Execute(parameter2);
}
public new void MarkForDeletion()
{
_staticFunc = null;
base.MarkForDeletion();
}
}
public interface IExecuteWithObjectAndResult
{
object ExecuteWithObject(object parameter);
}
#endregion RelayCommand
#region WeakAction
public class WeakAction
{
private Action _staticAction;
protected MethodInfo Method
{
get;
set;
}
public virtual string MethodName
{
get
{
if (_staticAction != null)
{
return _staticAction.GetMethodInfo().Name;
}
return Method.Name;
}
}
protected WeakReference ActionReference
{
get;
set;
}
protected object LiveReference
{
get;
set;
}
protected WeakReference Reference
{
get;
set;
}
public bool IsStatic => _staticAction != null;
public virtual bool IsAlive
{
get
{
if (_staticAction == null && Reference == null && LiveReference == null)
{
return false;
}
if (_staticAction != null)
{
if (Reference != null)
{
return Reference.IsAlive;
}
return true;
}
if (LiveReference != null)
{
return true;
}
if (Reference != null)
{
return Reference.IsAlive;
}
return false;
}
}
public object Target
{
get
{
if (Reference == null)
{
return null;
}
return Reference.Target;
}
}
protected object ActionTarget
{
get
{
if (LiveReference != null)
{
return LiveReference;
}
if (ActionReference == null)
{
return null;
}
return ActionReference.Target;
}
}
protected WeakAction()
{
}
public WeakAction(Action action, bool keepTargetAlive = false)
: this(action?.Target, action, keepTargetAlive)
{
}
public WeakAction(object target, Action action, bool keepTargetAlive = false)
{
if (action.GetMethodInfo().IsStatic)
{
_staticAction = action;
if (target != null)
{
Reference = new WeakReference(target);
}
}
else
{
Method = action.GetMethodInfo();
ActionReference = new WeakReference(action.Target);
LiveReference = (keepTargetAlive ? action.Target : null);
Reference = new WeakReference(target);
}
}
public void Execute()
{
if (_staticAction != null)
{
_staticAction();
return;
}
object actionTarget = ActionTarget;
if (IsAlive && (object)Method != null && (LiveReference != null || ActionReference != null) && actionTarget != null)
{
Method.Invoke(actionTarget, null);
}
}
public void MarkForDeletion()
{
Reference = null;
ActionReference = null;
LiveReference = null;
Method = null;
_staticAction = null;
}
}
public class WeakAction<T> : WeakAction, IExecuteWithObject
{
private Action<T> _staticAction;
public override string MethodName
{
get
{
if (_staticAction != null)
{
return _staticAction.GetMethodInfo().Name;
}
return base.Method.Name;
}
}
public override bool IsAlive
{
get
{
if (_staticAction == null && base.Reference == null)
{
return false;
}
if (_staticAction != null)
{
if (base.Reference != null)
{
return base.Reference.IsAlive;
}
return true;
}
return base.Reference.IsAlive;
}
}
public WeakAction(Action<T> action, bool keepTargetAlive = false)
: this(action?.Target, action, keepTargetAlive)
{
}
public WeakAction(object target, Action<T> action, bool keepTargetAlive = false)
{
if (action.GetMethodInfo().IsStatic)
{
_staticAction = action;
if (target != null)
{
base.Reference = new WeakReference(target);
}
}
else
{
base.Method = action.GetMethodInfo();
base.ActionReference = new WeakReference(action.Target);
base.LiveReference = (keepTargetAlive ? action.Target : null);
base.Reference = new WeakReference(target);
}
}
public new void Execute()
{
Execute(default(T));
}
public void Execute(T parameter)
{
if (_staticAction != null)
{
_staticAction(parameter);
return;
}
object actionTarget = base.ActionTarget;
if (IsAlive && (object)base.Method != null && (base.LiveReference != null || base.ActionReference != null) && actionTarget != null)
{
base.Method.Invoke(actionTarget, new object[1]
{
parameter
});
}
}
public void ExecuteWithObject(object parameter)
{
T parameter2 = (T)parameter;
Execute(parameter2);
}
public new void MarkForDeletion()
{
_staticAction = null;
base.MarkForDeletion();
}
}
public interface IExecuteWithObject
{
object Target
{
get;
}
void ExecuteWithObject(object parameter);
void MarkForDeletion();
}
#endregion WeakAction
VM继承Base后
首先属性变更通知
private string _inputPath = string.Empty;
public string InputPath
{
get { return _inputPath; }
set
{
if (!string.IsNullOrWhiteSpace(_inputPath) && _inputPath.Equals(value)) return;
_inputPath = value;
RasePropertyChanged("InputPath");//这里就是直接调用Base
}
}
其次Command事件
public ICommand ExcutedClicked => new RelayCommand(ExcuteConvert);//调Base
#endregion Event
public void ExcuteConvert()
{
//Do some thing
}
开始绑定ViewModel
- 这里仅画一个页面 且整个界面都是Grid画的 绑定整个页面数据源为ViewModel 并将其绑定至grid
//页面源绑定
<Window.Resources>
<local:ViewModelName x:Key="d" />
</Window.Resources>
//grid 源绑定
<Grid ShowGridLines="True" DataContext="{StaticResource d}"> //ShowGridLines="True" 可以显示布局虚线 使得页面布局更简单
然后你前端控件就可以直接绑定VM的属性 或是事件了
- 属性绑定 直接Binding VM的属性名就可以了
<TextBox Grid.Column="1" x:Name="InputPathText" Text="{Binding InputPath}" TextWrapping="Wrap" VerticalAlignment="Center" Height="24" />
- 事件绑定 Command="{Binding ExcutedClicked} 同理直接绑定VM 事件名
<Button Grid.Column="3" x:Name="ExcuteBtn" Content="执行" HorizontalAlignment="Center" VerticalAlignment="Center" Height="24" Width="60" Command="{Binding ExcutedClicked}" />
搞定 WPF就建好了