一篇文章，带你玩转MVVM，Dapper，AutoMapper

一、背景

由于现在做的项目都是采用WPF来进行UI设计，开发过程中都是基于MVVM来进行开发，但是项目中的MVVM并不是真正的把实体和视图进行解耦，而是将实体和视图完全融合起来，ViewModel只是用来实现View和Model的数据同步，违背了MVVM设计的数据双向绑定的初衷，完全没有发挥出MVVM的优势。

二、MVVM基本概念

1.M:表示Model，也就是一个实体对象。

2.V:表示VIew，也就是UI界面展示，即人机交互界面。

3.ViewModel：可以理解为搭建View和Model的一个业务逻辑桥梁。

三、Demo来说明

首先建立解决方案，方案框架如下：

在Models中创建一个Model实体对象Contacts

public class Contacts

    {

        public int ID { get; set; }

        public string FirstName { get; set; }

        public string LastName { get; set; }

        public string Email { get; set; }

        public string Company { get; set; }

        public string Title { get; set; }

    }

接下来我们在ViewModel中实现V和M的完全解耦，在ViewModels中添加ContractsViewModels

 public class ContractsViewModels : BaseViewModels

    {

       public  Contacts contracts = null;

        public ContractsViewModels(Contacts contracts)

        {

            this.contracts = contracts;

        }

        public ContractsViewModels()

        {

            contracts = new Contacts();

        }

        public int ID { get { return contracts.ID; } set { contracts.ID = value; OnPropertyChanged(this, nameof(ID)); } }

        public string FirstName { get { return contracts.FirstName; } set { contracts.FirstName = value; OnPropertyChanged(this, nameof(FirstName)); } }

        public string LastName { get { return contracts.LastName; } set { contracts.LastName = value; OnPropertyChanged(this, nameof(LastName)); } }

        public string Email { get { return contracts.Email; } set { contracts.Email = value; OnPropertyChanged(this, nameof(Email)); } }

        public string Company { get { return contracts.Company; } set { contracts.Company = value; OnPropertyChanged(this, nameof(Company)); } }

        public string Title { get { return contracts.Title; } set { contracts.Title = value; OnPropertyChanged(this, nameof(Title)); } }

    }

当数据双向绑定时，视图知道自己绑定了那个实体，为了让实体的属性改变中，能够通知绑定的View，我们需要实现INotifyPropertyChanged这个接口，具体实现如下

 public class BaseViewModels : INotifyPropertyChanged

    {

        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(object sender, string name)

        {

            if (PropertyChanged != null)

            {

                PropertyChanged(sender ?? this, new PropertyChangedEventArgs(name));

            }

        }

    }

以上实现，在ViewModel中改变属性，便可以轻松的通知到绑定时View控件，真正意义上实现了双向数据绑定。

接下来在ViewModel中添加ContractsVMServices来方便View的数据操作

代码如下：

  /// <summary>

    /// ContractsViewModels服务类

    /// </summary>

    public class ContractsVMServices

    {

        /// <summary>

        /// 加载所有数据的事件

        /// </summary>

        public event EventHandler OnLoadAllContracts;

        /// <summary>

        /// 数据集合对象

        /// </summary>

        public ObservableCollection<ContractsViewModels> ContractsViewModels { get; private set; }

        /// <summary>

        /// 单个实体的事件

        /// </summary>

        public event EventHandler OnLoadContracts;

        /// <summary>

        /// 单个实体

        /// </summary>

        public ContractsViewModels ContractsViewModel { get; private set; }

        private ContractsVMServices() { }

        public static ContractsVMServices Instances = new ContractsVMServices();

        /// <summary>

        /// 初始化

        /// </summary>

        public void Init()

        {

            ContractsViewModels = new ObservableCollection<ContractsViewModels>();

            ContractsViewModel = new ContractsViewModels(new Contacts());

            OnLoadAllContracts?.Invoke(this, EventArgs.Empty);

            OnLoadContracts?.Invoke(this, EventArgs.Empty);

            AutoMapperWrapper.Start();

            LoadAllContracts();

        }

        /// <summary>

        /// 定时模拟数据改变

        /// </summary>

        /// <param name="afterSecond"></param>

        /// <param name="freSecond"></param>

        public void ChangeByTime(int afterSecond = , int freSecond = )

        {

            Task.Run(async () =>

            {

                await Task.Delay(afterSecond * );

                while (true)

                {

                    try

                    {

                        foreach (var item in ContractsViewModels)

                        {

                            item.Title = "Change" + DateTime.Now.ToString();

                            string update = "Update contacts set Title=@Title where ID=@ID";

                            List<KeyValuePair<string, object>> ls = new List<KeyValuePair<string, object>>();

                            ls.Add(new KeyValuePair<string, object>(nameof(item.Title), item.Title));

                            ls.Add(new KeyValuePair<string, object>(nameof(item.ID), item.ID));

                            DapperHelper.Update(update, ls);

                        }

                        //string insert = @"Update into contacts (Id,FirstName,LastName,Email,Company,Title) values(@Id,@FirstName,@LastName,@Email,@Company,@Title)";

                    }

                    catch (Exception ex)

                    {

                    }

                    finally

                    {

                        await Task.Delay(freSecond * );

                    }

                }

            });

        }

        /// <summary>

        /// 从数据库中加载所有数据

        /// </summary>

        private void LoadAllContracts()

        {

            try

            {

                //Task.Run(() =>

                //{

                ContractsViewModels.Clear();

                List<Contacts> contracts = DBDapper.DapperHelper.Query<Contacts>("Contacts");

                // ContractsViewModels = AutoMapperWrapper.Map<List<Contacts>, ObservableCollection<ContractsViewModels>>(contracts);

                foreach (var item in contracts)

                {

                    //ContractsViewModels models= AutoMapperWrapper.Map<Contacts, ContractsViewModels>(item);

                    ContractsViewModels.Add(new ViewModels.ContractsViewModels(item));

                }

                //});

            }

            catch (Exception ex)

            {

                Console.WriteLine(  ex.ToString());

            }

        }

        /// <summary>

        /// 根据ID来加载指定数据

        /// </summary>

        /// <param name="id"></param>

        public void LoadOnContracts(int id)

        {

            ContractsViewModel = ContractsViewModels.Where(obj => obj.ID == id).FirstOrDefault();

        }

        /// <summary>

        /// 创建一个新的对象

        /// </summary>

        public void Add()

        {

            try

            {

                int id = ContractsViewModels.Count >  ? ContractsViewModels[ContractsViewModels.Count - ].ID +  : ;

                string insert = @"insert into contacts (Id,FirstName,LastName,Email,Company,Title) values(@Id,@FirstName,@LastName,@Email,@Company,@Title)";

                int res = DapperHelper.Insert<Contacts>(insert, new List<Contacts>() { new Contacts() { ID =id, FirstName = "", LastName = "", Email = "", Company = "", Title = "" } });

                if (res > )

                {

                    LoadAllContracts();

                }

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex.ToString());

            }

        }

        /// <summary>

        /// 删除对象

        /// 为了方便演示我只删除数据集合中的第一个对象

        /// </summary>

        public void Delete()

        {

            try

            {

                if (ContractsViewModels.Count > )

                {

                    string delete = "delete from Contacts where ID= @ID";

                    int res = DapperHelper.Delete(delete, new { ID = ContractsViewModels[].ID });

                    if (res > )

                    {

                        LoadAllContracts();

                    }

                }

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex.ToString());

            }

        }

    }

实现数据库的CRUD操作，我这里主要用到半自动化的ORM----Dapper。

老生常谈，首先需要从Nuget中安装Dapper，安装到DBDapper项目中。

或者在控制台中输入： Install -Package Dapper 完成Dapper下载安装。

创建一个DapperHelper帮助类

  public class DapperHelper

    {

        //三部曲

        //第一步：使用连接字符串创建一个IDBConnection对象；

        static IDbConnection conn = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["SqlServerConnString"].ToString());

        //第二步：编写一个查询并将其存储在一个普通的字符串变量中；

        public static  void test()

        {

            string query = "SELECT * from contacts;";

            List<Contacts> contracts=(List<Contacts>)conn.Query<Contacts>(query);

            Console.WriteLine( contracts.Count);

        }

        public static  List<T> Query<T>(string typeofName)

        {

            string query = $"SELECT * from {typeofName};";

            List<T> contracts = (List<T>)conn.Query<T>(query);

            return contracts;

        }

        public static  int Insert<T>(string sql,IEnumerable<T> ls)

        {

            try

            {

              return   conn.Execute(sql, ls);

            }

            catch (Exception ex)

            {

                throw new Exception(ex.ToString());

            }

        }

        public static int Update(string sql, IEnumerable<KeyValuePair<string,object>> ls)

        {

            try

            {

                return conn.Execute(sql, ls);

            }

            catch (Exception ex)

            {

                throw new Exception(ex.ToString());

            }

        }

        public static int Delete(string sql, object obj)

        {

            try

            {

                return conn.Execute(sql, obj);

            }

            catch (Exception ex)

            {

                throw new Exception(ex.ToString());

            }

        }

        //public static int Update<T>(string sql, List<T> ls)

        //{

        //}

        //第三步：调用db.execute()并传递查询，完成。

    }

看上面的三步曲，和ADO.net大同小异，不过我们再也不用将数据库表的数据转换成实体了，采用Dapper便傻瓜式的转换了。

看我们的代码，我们会发现，Model跟View完全独立，不过这个时候，ViewModel会多出跟Model一样的一个实体出来，为了实现Model到ViewModel的一个完美映射，我这里采用了AutoMapper来实现映射。

老套路，我们从Nuget中下载AutoMapper，安装到ViewModels。

或者在控制台中输入： Install -Package AutoMapper完成AutoMapper下载安装。

在ViewModels中建立AutoMapper的一个包装类AutoMapperWrapper，AutoMapper需要初始化应映射规则，因此我们需要先创建一个映射

public class SourceProfile : MapperConfigurationExpression

    {

        public SourceProfile()

        {

            base.CreateMap<ContractsViewModels, Contacts>();

            base.CreateMap<Contacts, ContractsViewModels>();

            //base.CreateMap<ContractsViewModels,Models.Contracts>();

        }

    }

AutoMapperWrapper如下：

public class AutoMapperWrapper

    {

        //protected DTOObject Result { get; set; }

        //protected IEnumerable<DTOObject> Results { get; set; }

        static   Mapper mapper = null;

        public static void Start()

        {

            MapperConfiguration configuration = new MapperConfiguration(new SourceProfile());

            mapper =  new Mapper(configuration);

           // mapper.Map<,>

          //  Mapper

            //new SourceProfile();

        }

        public static T Map<S, T>(S soure)

        {

            T to = mapper.Map<S, T>(soure);

            return to;

        }

    }

以上我们便实现了一个ViewModel,DB的后台管理。接下来我们来看一个View怎么实现数据的绑定

先看一下代码

<Window x:Class="View.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:View"

        mc:Ignorable="d"

        Title="MainWindow" Height="" Width="" Loaded="Window_Loaded">

    <Grid>

        <DataGrid x:Name="datagrid" ItemsSource="{Binding ContractsViewModels}" AutoGenerateColumns="False" HorizontalAlignment="Left" Height="" Margin="72,70,0,0" VerticalAlignment="Top" Width="">

            <DataGrid.Columns>

                <DataGridTextColumn Header="ID" Binding="{Binding ID}"></DataGridTextColumn>

                <DataGridTextColumn Header="FirstName" Binding="{Binding FirstName}"></DataGridTextColumn>

                <DataGridTextColumn Header="LastName" Binding="{Binding LastName}"></DataGridTextColumn>

                <DataGridTextColumn Header="Email" Binding="{Binding Email}"></DataGridTextColumn>

                <DataGridTextColumn Header="Company" Binding="{Binding Company}"></DataGridTextColumn>

                <DataGridTextColumn Header="Title" Binding="{Binding Title}"></DataGridTextColumn>

            </DataGrid.Columns>

        </DataGrid>

        <Button x:Name="btn_LoadAll" Content="加载所有Contract数据" HorizontalAlignment="Left" Margin="97,372,0,0" VerticalAlignment="Top" Click="btn_LoadAll_Click"/>

        <Button x:Name="btn_ChangeByTime" Content="定时改变" HorizontalAlignment="Left" VerticalAlignment="Top" Width="" Margin="284,372,0,0" Click="btn_ChangeByTime_Click"/>

        <Button x:Name="btn_Delete" Content="删除" HorizontalAlignment="Left" Margin="417,372,0,0" VerticalAlignment="Top" Width="" Click="btn_Delete_Click"/>

        <TextBox x:Name="textBox" HorizontalAlignment="Left" Height="" Margin="591,144,0,0" TextWrapping="Wrap" Text="{Binding ContractsViewModel.FirstName,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}" VerticalAlignment="Top" Width=""/>

        <Label Content="FirstName" HorizontalAlignment="Left" Margin="506,141,0,0" VerticalAlignment="Top"/>

    </Grid>

</Window>

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

namespace View

{

    /// <summary>

    /// MainWindow.xaml 的交互逻辑

    /// </summary>

    public partial class MainWindow : Window

    {

        public MainWindow()

        {

            InitializeComponent();

        }

        private void Window_Loaded(object sender, RoutedEventArgs e)

        {

            try

            {

                ViewModels.ContractsVMServices.Instances.OnLoadAllContracts += (s, es) => {

                    this.Dispatcher.InvokeAsync(() => datagrid.DataContext = s);

                };

                ViewModels.ContractsVMServices.Instances.OnLoadContracts += (s, es) => {

                    this.Dispatcher.InvokeAsync(() => textBox.DataContext = s);

                };

                ViewModels.ContractsVMServices.Instances.Init();

                ViewModels.ContractsVMServices.Instances.LoadOnContracts();

            }

            catch (Exception ex)

            {

            }

        }

        private void btn_LoadAll_Click(object sender, RoutedEventArgs e)

        {

            ViewModels.ContractsVMServices.Instances.Add();

        }

        private void btn_ChangeByTime_Click(object sender, RoutedEventArgs e)

        {

            ViewModels.ContractsVMServices.Instances.ChangeByTime();

        }

        private void btn_Delete_Click(object sender, RoutedEventArgs e)

        {

            ViewModels.ContractsVMServices.Instances.Delete();

        }

    }

}

以上我们看到DataGrid的ItemsSource必须要先绑定一个源，这个源的名称跟我们ViewModel中的数据集合是一致的。修改TextBox中的数据的时候我们发现DataGrid的数据也跟着改变。以上就是实现V与M的一个解耦。

巴特西

一篇文章，带你玩转MVVM，Dapper，AutoMapper

最新文章

热门文章