WPF MvvmLight

关于

停止更新

官网：http://www.mvvmlight.net/

源码地址：GitHub - lbugnion/mvvmlight: The main purpose of the toolkit is to accelerate the creation and development of MVVM applications in Xamarin.Android, Xamarin.iOS, Xamarin.Forms, Windows 10 UWP, Windows Presentation Foundation (WPF), Silverlight, Windows Phone.、https://archive.codeplex.com/?p=mvvmlight（迁移到Github）

开始

通过Nuget平台，引入相关库

框架中的数据与行为

数据绑定与通知：INotifyPropertyChanged

默认：自定义

框架：ObservableObject、ViewModelBase（VM的资源释放）

Model：

public class MainModel : ObservableObject { }

ViewModel：

通知方式：RaisePropertyChanged、Set

public class MainViewModel : ViewModelBase 
{
     private string _value = "Hello";

     public string Value
     {
         get { return _value; }
         set
         {
             // 第一种通知方式
             //this.RaisePropertyChanged();
             //_value = value;
    
             // 第二种通知方式 建议第二种
             Set<string>(ref _value, value);
         }
     }
    // 作用：统一执行对象的资源清理 VM的释放
    // View关闭退出的时候 后台线程需要结束
    public override void Cleanup()
    {
        base.Cleanup();
    }
}

Cleanup：统一执行对象的资源清理 VM的释放

手写MvvmLight中的值通知方法

 public class NotifyBase : INotifyPropertyChanged
 {
     public event PropertyChangedEventHandler? PropertyChanged;

     public void SetProperty<T>(ref T propertyName,T value, [CallerMemberName] string propName = "")
     {
         if (propertyName is null || !propertyName.Equals(value))
         {
             propertyName = value;
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propName));
         }
     }
 }

命令绑定对象：ICommand

默认：自定义

框架：RelayCommand、RelayCommand<T>

 public RelayCommand BtnCommand { get; set; }
 public RelayCommand<object> BtnParamCommand { get; set; }

public MainViewModel()
{

    // 第二个参数：按钮是否可以点击按钮状态
    BtnCommand = new RelayCommand(DoButtonCommand, DoButtonStatus);
    BtnParamCommand = new RelayCommand<object>(DoBtnParamCommand);
}

 private void DoButtonCommand()
 {

 }
  
 private bool DoButtonStatus()
 {
     return Value == "Hello";
 }

 private void DoBtnParamCommand(object obj)
 {
     
 }

设计模式IsInDesignMode

if (this.IsInDesignMode)
{
    // 设计时 模拟数据处理 
}
else
{
    // 运行时执行
}

设计模式也可以用xaml写：

<Window x:Class="XH.MvvmLightLesson.Views.MainWindow"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
  xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
  xmlns:local="clr-namespace:XH.MvvmLightLesson.Views"
  mc:Ignorable="d" 
  xmlns:vm="clr-namespace:XH.MvvmLightLesson.ViewModels"
  Title="MainWindow" Height="450" Width="800">
  <!--d:也是设计时的显示，运行不显示-->
  <d:Window.DataContext>
    <vm:MainViewModel />
  </d:Window.DataContext>
</Window>

扩展对象

Messenger：

解决对象间的逻辑调用（使得VM可以调用View层面的对象）

注册（委托方法）、发布（主动请求执行这个委托方法）、反注册

注册：在主窗口或者APP.xaml.cs中写方法，主要是View层面的注册

 public MainWindow()
 {
     InitializeComponent();

     // MvvmLight基本的注册过程
     Messenger.Default.Register<string>(this, ExecuteMessage);

     // 如果需要区分这两个执行逻辑 两个方法：
     // 1、使用Token（Key）
     Messenger.Default.Register<string>(this,"SubWin", ExecuteMessageSubWin);
     // 2、使用类型区分 复杂的数据传参
     Messenger.Default.Register<Base.MessageBase>(this, ExecuteMessageType);
 }
private void ExecuteMessageType(Base.MessageBase obj)
{
    var result = new SubWindow { Owner = this }.ShowDialog() == true;

    obj.Action?.Invoke(result);
}

private void ExecuteMessageSubWin(string obj)
{
    new SubWindow { Owner = this }.ShowDialog();
}

复杂类型类：这里用了更加复杂的委托

 public class MessageBase
 {
     public string Value { get; set; }
     public Action<bool> Action { get; set; }
 }

发布（主动请求）：

private void DoBtnParamCommand(object obj)
{
    // 主动 发布
    // 根据类型绑定、Key
    //Messenger.Default.Send<string>(Value);
    //Messenger.Default.Send<string>(Value, "SubWin");
    Messenger.Default.Send<Base.MessageBase>(new Base.MessageBase { Value = Value, 
        Action = GetResult });
}
private void GetResult(bool obj)
{

}

顺序：

Register -->Send -->ExecuteMessageType-->GetResult

DispatcherHelper

跨线程、初始化、应用中任意地方调用

DispatcherHelper初始化：在APP中初始化

public partial class App : Application
{
    public App()
    {
        // DispatcherHelper 初始化
        DispatcherHelper.Initialize();
    }
}

使用：再需要跨线程使用的时候，使用此方法：

 Task.Run(async () =>
 {
     await Task.Delay(2000);
     while (true)
     {
         DispatcherHelper.CheckBeginInvokeOnUI(() =>
         {
             ValueList.Add($"Xiao Hai{ValueList.Count}");
         });
         // 和下方方法一样
         //Application.Current.Dispatcher.Invoke(() =>
         //{
         //    ValueList.Add($"Xiao Hai{ValueList.Count}");
         //});
     }
 });

注意：

DispatcherHelper.CheckBeginInvokeOnUI：异步执行

Application.Current.Dispatcher.Invoke：同步执行

SimpleIoC

在全局APP.xaml中使用

 <Application.Resources>
     <ResourceDictionary>
         <vm:ViewModelCenter x:Key="Center" />
     </ResourceDictionary>
 </Application.Resources>

ViewModelCenter中写法：

public class ViewModelCenter
{
    SimpleIoc _simpleIoc = SimpleIoc.Default;

    public ViewModelCenter()
    {
        // 注册一个Ioc实例
        _simpleIoc.Register<IDataAccess, MySqlDA>();
        _simpleIoc.Register<MainViewModel>();
        _simpleIoc.Register<SubViewModel>();

        // 创建多个实例 untiy  --  key
        // SimpleIoc：不可以重复创建实例
        //_simpleIoc.Register<IDataAccess,SqlServerDA>();

    }

    // GetInstance：获取一个实例
    public MainViewModel MainWin { get => _simpleIoc.GetInstance<MainViewModel>(); }
    public SubViewModel SubWin { get => _simpleIoc.GetInstance<SubViewModel>(); }
}

在页面xaml中，数据传达方式：

DataContext="{Binding Source={StaticResource Center},Path=MainWin}"

总结：

IOC就当与是个容器，可以在全局中设置一些数据的初始化，可以直接在构造函数中进行传入已经实例化的全局对象，切记对象在IOC中已经实例化，并且只能实例化一次，不会重复实例化。

自定义IOC：

 public class XiaohaiIoc
 {
     private static XiaohaiIoc _default;
     private static readonly object _instanceLock = new object();
     // IOC初始化
     public static XiaohaiIoc Default
     {
         get
         {
             if (_default == null)
             {
                 lock (_instanceLock)
                 {
                     if (_default == null)
                     {
                         _default = new XiaohaiIoc();
                     }
                 }
             }
             return _default;
         }
     }
     // 防止被初始化new 
     private XiaohaiIoc() { }
     
     Dictionary<string, Type> _objectDic = new Dictionary<string, Type>();
     
     public void Register<T>()
     {
         _objectDic.Add(typeof(T).FullName!, typeof(T));
     }
     // TTo 必须继承或引用 TFrom
     public void Register<TFrom, TTo>() where TTo : TFrom
     {
         _objectDic.Add(typeof(TFrom).FullName!, typeof(TTo));
     }
     public T Resolve<T>()
     {
         string key = typeof(T).FullName!;
         if (_objectDic.ContainsKey(key))
         {
             // 创建新的实例 并返回
             return (T)Activator.CreateInstance(_objectDic[key])!;
         }
         else
             return default(T)!;
     }
 }

缺点：每次掉用都是新的实例，每次都初始化，导致数据会丢失

优化：单例的IOC容器：

using GalaSoft.MvvmLight.Ioc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace XH.MvvmLightLesson.Base
{
    public class XiaohaiIoc
    {
        private static XiaohaiIoc _default;
        // 防止重复初始化new 对象，加个锁
        private static readonly object _instanceLock = new object();
        // 初始化 ioc
        public static XiaohaiIoc Default
        {
            get
            {
                if (_default == null)
                {
                    lock (_instanceLock)
                    {
                        if (_default == null)
                        {
                            _default = new XiaohaiIoc();
                        }
                    }
                }
                return _default;
            }
        }
        // 防止外面初始化此ioc
        private XiaohaiIoc() { }
        Dictionary<string, InstenceModel> _instenceDic = new Dictionary<string, InstenceModel>();

        public void RegisterSingle<T>()
        {
            _instenceDic.Add(typeof(T).FullName!,
                new InstenceModel
                {
                    ObjectType = typeof(T)
                });
        }

        public void RegisterSingle<TFrom, TTo>() where TTo : TFrom
        {
            _instenceDic.Add(typeof(TFrom).FullName!, new InstenceModel
            {
                ObjectType = typeof(TTo)
            });
        }

        public T ResolveSingle<T>()
        {
            string key = typeof(T).FullName!;
            if (_instenceDic.ContainsKey(key))
            {
                if (_instenceDic[key].Instence is null)
                {
                    // 获取所有的构造函数
                    ConstructorInfo[] cis = _instenceDic[key].ObjectType.GetConstructors();
                    // 获取所有的参数
                    ParameterInfo[] pis = cis[0].GetParameters();
                    // 创建args 参数列表
                    List<object> objects = new List<object>();
                    foreach (ParameterInfo pi in pis)
                    {
                        string paramTypeKey = pi.ParameterType.FullName!;
                        if (_instenceDic.ContainsKey(paramTypeKey!))
                        {
                            if (_instenceDic[paramTypeKey].Instence is null)
                                _instenceDic[paramTypeKey].Instence = Activator.CreateInstance(_instenceDic[paramTypeKey].ObjectType)!;
                            objects.Add(_instenceDic[paramTypeKey].Instence);
                        }
                        else
                            objects.Add(null!);
                    }
                    // 实例化对象
                    var obj = Activator.CreateInstance(_instenceDic[key].ObjectType, objects.ToArray());
                    _instenceDic[key].Instence = obj!;
                }
                return (T)_instenceDic[key].Instence;
            }
            else
                return default(T)!;
        }
    }

    // 单例的初始化对象
    class InstenceModel
    {
        public Type ObjectType { get; set; } // 类型
        public object Instence { get; set; } // 初始化的内容 如果存在证明已经初始化
    }
}

使用：和simpleIoc 使用方法一样：

public class ViewModelCenter
{
    // 自定义IOC容器
    XiaohaiIoc _xiaohaiIoc = XiaohaiIoc.Default;
    public ViewModelCenter()
    {
        // 注册一个Ioc实例
        _xiaohaiIoc.Register<MainViewModel>();

        var model = MainWin;
        MainWin.Value = "ABC";
        var model1 = MainWin;
    }

    public MainViewModel MainWin { get => _xiaohaiIoc.Resolve<MainViewModel>(); }
}

在app.xaml中调用是一样的，在页面中数据绑定也是一样的。

结合IoC模式下的资源释放问题

MainViewModel代码：

 public override void Cleanup()
 {
     base.Cleanup();
 }

ViewModelCenter代码：

参数T 必须继承于ViewModelBase

public static void Cleanup<T>() where T : ViewModelBase
{
    _xiaohaiIoc.Resolve<T>().Cleanup();
}

MainWindow.xaml.cs代码：

 protected override void OnClosed(EventArgs e)
 {
     base.OnClosed(e);

     // 拿到Center 中对应的VM
     ViewModelCenter.Cleanup<MainViewModel>();
 }