稳扎稳打Silverlight(58) 4.0通信之WCF RIA Services: 通过 Domain Service, 以 MVVM 模式实现数据的添加、删除、修改和查询

[索引页]
[源码下载]

稳扎稳打Silverlight(58) - 4.0通信之WCF RIA Services: 通过 Domain Service, 以 MVVM 模式实现数据的添加、删除、修改和查询

作者：webabcd


介绍
Silverlight 4.0 之 WCF RIA Services：DomainService 和 MVVM


在线DEMO
http://www.cnblogs.com/webabcd/archive/2010/08/09/1795417.html


示例
演示如何通过 Domain Service, 以 MVVM 模式实现数据的添加、删除、修改和查询
1、服务端
MyDomainService.cs

/*
 * 一个 Domain Service 服务
 */

namespace Silverlight40.Web.Service
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.ComponentModel.DataAnnotations;
    using System.Data;
    using System.Linq;
    using System.ServiceModel.DomainServices.EntityFramework;
    using System.ServiceModel.DomainServices.Hosting;
    using System.ServiceModel.DomainServices.Server;
    using Silverlight40.Web.Model;

    /*
     * 用 LinqToEntities 实现 Domain Service 则继承 LinqToSqlDomainService<NorthwindEntities>；用 LinqToSql 实现 Domain Service 则继承 LinqToSqlDomainService<NorthwindEntities>
     * Domain Service 内所有对客户端可见的方法都应该是 public 的，Domain Service 内的方法不支持重载
     * 对客户端可见的方法要满足命名约定，或为其指定对应的 Attribute。当前支持 6 种数据操作：Query, Update, Insert, Delete, Invoke, Named Update, 详见文档
     * 
     * [EnableClientAccess()] - 该类对客户端可见
     * [EnableClientAccess(RequiresSecureEndpoint = true)] - 使用 HTTPS 协议
     * [Ignore] - 指定的方法不作为服务而公开
     * [Query(IsComposable=true)] - 支持客户端的 linq 查询，而且此查询会被在服务端执行
     * 
     * 在多个 Domain Services 间共享实体：通过 [ExternalReference], [Association()], Context.AddReference() 实现，详见文档
     */

    // 服务端的类名为：MyDomainService，则其生成的客户端上下文的类名为：MyDomainContext
    [EnableClientAccess()]
    public class MyDomainService : LinqToEntitiesDomainService<NorthwindEntities>
    {
        [Query(IsDefault = true)]
        public IQueryable<Category> GetCategories()
        {
            return this.ObjectContext.Categories;
        }

        public void InsertCategory(Category category)
        {
            if ((category.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(category, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Categories.AddObject(category);
            }
        }

        public void UpdateCategory(Category currentCategory)
        {
            this.ObjectContext.Categories.AttachAsModified(currentCategory, this.ChangeSet.GetOriginal(currentCategory));
        }

        public void DeleteCategory(Category category)
        {
            if ((category.EntityState == EntityState.Detached))
            {
                this.ObjectContext.Categories.Attach(category);
            }
            this.ObjectContext.Categories.DeleteObject(category);
        }



        [Query(IsDefault = true)]
        public IQueryable<Product> GetProducts()
        {
            return this.ObjectContext.Products;
        }

        public IQueryable<Product> GetProductsBySort(string sort)
        {
            return ObjectContext.Products.OrderBy(sort);
        }

        public void InsertProduct(Product product)
        {
            if ((product.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(product, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Products.AddObject(product);
            }
        }

        public void UpdateProduct(Product currentProduct)
        {
            this.ObjectContext.Products.AttachAsModified(currentProduct, this.ChangeSet.GetOriginal(currentProduct));
        }

        public void DeleteProduct(Product product)
        {
            if ((product.EntityState == EntityState.Detached))
            {
                this.ObjectContext.Products.Attach(product);
            }
            this.ObjectContext.Products.DeleteObject(product);
        }

        public IQueryable<Product> GetProductsByCategoryId(int categoryId)
        {
            return this.ObjectContext.Products.Where(p => p.CategoryID == categoryId);
        }
    }
}

MyDomainService.metadata.cs

/*
 * [MetadataTypeAttribute()] - 指定类的元数据对象
 * [Include] - 生成的客户端上下文包含此字段
 * [Exclude] - 生成的客户端上下文不包含此字段
 * [Composition] - 指定字段为关联数据，即父实体增删改查时，此关联数据也会做相应的变化。指定此 Attribute 后，需显式指定其为 [Include]
 * [Editable(true)], [Editable(false)] - 指定字段是否可编辑
 */

namespace Silverlight40.Web.Model
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.ComponentModel.DataAnnotations;
    using System.Data.Objects.DataClasses;
    using System.Linq;
    using System.ServiceModel.DomainServices.Hosting;
    using System.ServiceModel.DomainServices.Server;

    [MetadataTypeAttribute(typeof(Category.CategoryMetadata))]
    public partial class Category
    {
        internal sealed class CategoryMetadata
        {
            private CategoryMetadata()
            {
            }

            [Key()]
            public int CategoryID { get; set; }

            [Display(Name = "类别名称")] // 显示用
            public string CategoryName { get; set; }

            public string Description { get; set; }

            [Exclude]
            public byte[] Picture { get; set; }

            [Include]
            // [Composition]
            public EntityCollection<Product> Products { get; set; }
        }
    }

    [MetadataTypeAttribute(typeof(Product.ProductMetadata))]
    public partial class Product
    {
        internal sealed class ProductMetadata
        {
            private ProductMetadata()
            {
            }

            public Category Category { get; set; }

            public Nullable<int> CategoryID { get; set; }

            public bool Discontinued { get; set; }

            public EntityCollection<Order_Detail> Order_Details { get; set; }

            [Display(Order = 0, Name = "产品ID")]
            public int ProductID { get; set; }

            [Display(Order = 1, Name = "产品名称")]
            public string ProductName { get; set; }

            public string QuantityPerUnit { get; set; }

            public Nullable<short> ReorderLevel { get; set; }

            public Supplier Supplier { get; set; }

            public Nullable<int> SupplierID { get; set; }

            public Nullable<decimal> UnitPrice { get; set; }

            public Nullable<short> UnitsInStock { get; set; }

            public Nullable<short> UnitsOnOrder { get; set; }
        }
    }
}

2、客户端
ProductViewModel.cs

/*
 * 演示：通过 Domain Service, 以 MVVM 模式实现数据的添加、删除、修改和查询
 * 此类为 MVVM 中的 ViewModel
 */

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

using Silverlight40.Web.Model;
using System.Collections.ObjectModel;
using Silverlight40.Web.Service;
using System.ComponentModel;
using System.ServiceModel.DomainServices.Client;
using System.Collections.Generic;

namespace Silverlight40.WCFRIAServices.DomainServiceAndMVVM
{
    public class ProductViewModel
    {
        public ObservableCollection<Product> Data { get; set; }
       
        private MyDomainContext _context;

        public ProductViewModel()
        {
            Data = new ObservableCollection<Product>();

            LoadData();
        }

        private void LoadData()
        {
            _context = new MyDomainContext();

            EntityQuery<Product> query = _context.GetProductsQuery().OrderByDescending(p => p.ProductID);

            /*
             * System.ServiceModel.DomainServices.Client.LoadOperation - 用于异步加载
             * System.ServiceModel.DomainServices.Client.InvokeOperation - 用于异步调用
             * System.ServiceModel.DomainServices.Client.SubmitOperation - 用于异步提交
             */

            LoadOperation<Product> lo = _context.Load(query);

            lo.Completed += delegate
            {
                Data.Clear();
                foreach (Product p in lo.Entities)
                {
                    Data.Add(p);
                }
            };
        }


        public ICommand FilterCommand
        {
            get { return new FilterCommand(this); }
        }
        public ICommand InsertCommand
        {
            get { return new InsertCommand(this); }
        }
        public ICommand DeleteCommand
        {
            get { return new DeleteCommand(this); }
        }
        public ICommand UpdateCommand
        {
            get { return new UpdateCommand(this); }
        }


        // 检索数据
        public void Filter(string productName)
        {
            EntityQuery<Product> query = _context.GetProductsQuery().Where(p => p.ProductName.Contains(productName));

            LoadOperation<Product> lo = _context.Load(query);

            lo.Completed += delegate
            {
                Data.Clear();

                foreach (Product p in lo.Entities)
                {
                    Data.Add(p);
                }
            };
        }

        
        // 插入数据
        public void Insert(string productName)
        {            
            EntitySet<Product> products = _context.EntityContainer.GetEntitySet<Product>();
            Product product = new Product();
            product.ProductName = productName;
            product.CategoryID = 1;
            product.SupplierID = 1;
            products.Add(product);

            _context.SubmitChanges(OnInsertCompleted, product);
        }
        private void OnInsertCompleted(SubmitOperation so)    
        {
            if (!so.HasError)
            {
                Data.Insert(0, so.UserState as Product);
            }
        }


        // 删除数据
        public void Delete(List<Product> products)
        {
            EntitySet<Product> productsOriginal = _context.EntityContainer.GetEntitySet<Product>();
            foreach (Product product in products)
            {
                productsOriginal.Remove(product);
            }

            _context.SubmitChanges(OnDeleteCompleted, products);
        }
        private void OnDeleteCompleted(SubmitOperation so)
        {
            if (!so.HasError)
            {
                List<Product> products = so.UserState as List<Product>;
                foreach (Product product in products)
                {
                    Data.Remove(product);
                }
            }
        }


        // 更新数据
        public void Update()
        {
            _context.SubmitChanges(OnUpdateCompleted, null);
        }
        private void OnUpdateCompleted(SubmitOperation so)
        {
            if (!so.HasError)
            {
                MessageBox.Show("更新成功");
            }
        }
    }
}

InsertCommand.cs

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace Silverlight40.WCFRIAServices.DomainServiceAndMVVM
{
    /// <summary>
    /// 插入的 Command
    /// </summary>
    public class InsertCommand : ICommand
    {
        private ProductViewModel _viewModel;

        public InsertCommand(ProductViewModel viewModel)
        {
            _viewModel = viewModel;
        }

        public bool CanExecute(object parameter)
        {
            return true;
        }

        public event EventHandler CanExecuteChanged;

        // 参数为：productName
        public void Execute(object parameter)
        {
            var productName = (string)parameter;
            _viewModel.Insert(productName);
        }
    }
}

DeleteCommand.cs

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

using Silverlight40.Web.Model;
using System.Collections.Generic;

namespace Silverlight40.WCFRIAServices.DomainServiceAndMVVM
{
    /// <summary>
    /// 删除的 Command
    /// </summary>
    public class DeleteCommand  : ICommand
    {
        private ProductViewModel _viewModel;

        public DeleteCommand(ProductViewModel viewModel)
        {
            _viewModel = viewModel;
        }

        public bool CanExecute(object parameter)
        {
            return true;
        }

        public event EventHandler CanExecuteChanged;

        // 参数为：DataGrid.SelectedItems [System.Collections.IList 类型]
        public void Execute(object parameter)
        {
            var collection = parameter as System.Collections.IList;
            var products = new List<Product>();

            foreach (Product product in collection)
            {
                products.Add(product);
            }

            _viewModel.Delete(products);
        }
    }
}

UpdateCommand.cs

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace Silverlight40.WCFRIAServices.DomainServiceAndMVVM
{
    /// <summary>
    /// 更新的 Command
    /// </summary>
    public class UpdateCommand : ICommand
    {
        private ProductViewModel _viewModel;

        public UpdateCommand(ProductViewModel viewModel)
        {
            _viewModel = viewModel;
        }

        public bool CanExecute(object parameter)
        {
            return true;
        }

        public event EventHandler CanExecuteChanged;

        public void Execute(object parameter)
        {
            _viewModel.Update();
        }
    }
}

FilterCommand.cs

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace Silverlight40.WCFRIAServices.DomainServiceAndMVVM
{
    /// <summary>
    /// 查询的 Command
    /// </summary>
    public class FilterCommand : ICommand
    {
        private ProductViewModel _viewModel;

        public FilterCommand(ProductViewModel viewModel)
        {
            _viewModel = viewModel;
        }

        public bool CanExecute(object parameter)
        {
            return true;
        }

        public event EventHandler CanExecuteChanged;

        // 参数为：productName
        public void Execute(object parameter)
        {
            var productName = (string)parameter;
            _viewModel.Filter(productName);
        }
    }
}
 

Demo.xaml

<navigation:Page x:Class="Silverlight40.WCFRIAServices.DomainServiceAndMVVM.Demo" 
           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:navigation="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Navigation"
           xmlns:sdk="http://schemas.microsoft.com/winfx/2006/xaml/presentation/sdk"
           xmlns:vm="clr-namespace:Silverlight40.WCFRIAServices.DomainServiceAndMVVM"
           Title="Demo Page">
    <Grid x:Name="LayoutRoot">
        <StackPanel HorizontalAlignment="Left">

            <!--
                在 View 中引入 ViewModel
            -->
            <StackPanel.DataContext>
                <vm:ProductViewModel />
            </StackPanel.DataContext>
            
            <!--
                用于演示添加记录
            -->
            <StackPanel Orientation="Horizontal">
                <sdk:Label Name="lblProductName4Add" Content="产品名称（添加用）:" />
                <TextBox Name="txtProductName4Add" Width="100" />
                <Button Name="btnAdd" Content="新增" Command="{Binding InsertCommand}" CommandParameter="{Binding ElementName=txtProductName4Add, Path=Text }" />
            </StackPanel>

            <!--
                用于演示查询记录
            -->
            <StackPanel Orientation="Horizontal">
                <sdk:Label Name="lblProductName" Content="产品名称（查询用）:" />
                <TextBox Name="txtProductName" Width="100" />
                <!--
                    如果 Command 需要传递多个参数，则可以
                        1、将 CommandParameter 绑定到一个容器控件，然后在 Command 中去遍历容器控件内的控件（破坏 ViewModel）
                        2、在 View 中调用 Command 之前构造一个复杂类型，再传递给 ViewModel（破坏 View）
                        3、ViewModel 中设置一个对象，其是 Model 层中的某个类的实例，同时此对象双向绑定到 View 上，这样这个复杂类型就可以通过 ViewModel 来传递
                -->
                <Button Name="btnFilter" Content="查询" Command="{Binding FilterCommand}" CommandParameter="{Binding ElementName=txtProductName, Path=Text }" />
            </StackPanel>

            <!--
                用于演示显示记录
            -->
            <sdk:DataGrid Name="dataGrid" Width="600" Height="300" AutoGenerateColumns="False" ItemsSource="{Binding Data}">
                <sdk:DataGrid.Columns>
                    <sdk:DataGridTextColumn Header="供应商ID" Binding="{Binding SupplierID}" IsReadOnly="True" />
                    <sdk:DataGridTextColumn Header="产品类别ID" Binding="{Binding CategoryID}" IsReadOnly="True" />
                    <sdk:DataGridTextColumn Header="产品ID" Binding="{Binding ProductID}" IsReadOnly="True" />
                    <sdk:DataGridTextColumn Header="产品名称" Binding="{Binding ProductName}" />
                </sdk:DataGrid.Columns>
            </sdk:DataGrid>

            <!--
                用于演示删除记录
            -->
            <Button Name="btnDelete" Content="删除选中（可多选）" Command="{Binding DeleteCommand}" CommandParameter="{Binding ElementName=dataGrid, Path=SelectedItems }" />

            <!--
                用于演示更新记录
            -->
            <Button Name="btnSave" Content="保存全部" Command="{Binding UpdateCommand}" />
            
        </StackPanel>
    </Grid>
</navigation:Page>

OK
[源码下载]