博客园_liulun

【翻译】在没有安装ASP.NET MVC3的服务器上运行ASP.NET MVC3的程序-scottgu

2012-02-05T04:16:00Z

原文地址：

http://weblogs.asp.net/scottgu/archive/2011/01/18/running-an-asp-net-mvc-3-app-on-a-web-server-that-doesn-t-have-asp-net-mvc-3-installed.aspx

为了更符合中文阅读习惯，我对原文做了小幅度修改

最近我们发布了一些新的Web产品 - 包括ASP.NET MVC 3。至今为止，我们已经获得了大量的反馈。

有几个朋友在问我一个问题：“我的网站托管服务提供商目前还不支持ASP.NET MVC 3 - 你知道他们将来什么时候会安装吗？”

好消息是，您不必等他们在Web服务器上安装ASP.NET MVC3。

只要您的网站托管服务提供商支持.NET 4，那么您现在就可以构建和部署ASP.NET MVC3应用程序了

- 不用托管供应商做任何事。

下面的文章介绍如何启用此功能。

一些背景：
我们支持两种方式使您可以使用一台机器上的ASP.NET MVC3组件：
1，在一台机器上，将ASP.NET MVC 3组件安装在一个集中的地方，WEB项目在那里引用这些组件

2，把ASP.NET MVC 3的组件复制到您的Web项目的\bin文件夹下，WEB项目在那里引用这些组件

第一种方法是我们使用Visual Studio中使用的默认方法，

这使得我们可以更容易为ASP.NET MVC 3提供升级服务（当发现BUG的时候）。

第二种方法也是得到了完全支持，没有在服务器上安装ASP.NET MVC3，也可以使用它。

你只要把ASP.NET MVC的组件放在你的WEB程序的bin目录中，然后把整个Web程序拷贝到FTP（WEB服务器）上，它就可以工作了。

如果您的网站托管服务提供商还没有在他们的服务器上安装ASP.NET MVC 3，那么您应该使用第二种方法。

方法1：基于GAC引用ASP.NET MVC组件
当您在计算机上安装ASP.NET MVC 3的时候，

一些组件会自动注册到GAC中（全局程序集缓存）。

GAC提供一个集中的地方供安装和升级（通过Windows更新）.NET程序集。

因此ASP.NET MVC3项目默认在这里引用程序集。

如果你复制一个普通的ASP.NET MVC 3项目（使用默认的方法引用ASP.NET MVC3的程序集）

到一台没有安装ASP.NET MVC3的机器上，

当你运行应用程序时，

会看到一个类似的错误信息：

上述错误表示，

至少有一个运行ASP.NET MVC 3所需的程序集在GAC中找不到。

在机器上安装ASP.NET MVC 3就能解决这个问题，

让您的应用程序正常运行。

方法2：基于\ Bin目录中引用ASP.NET MVC组件
您的项目可以使用另一种方法

在您的Web应用程序的\bin目录中分发和引用的ASP.NET MVC3的程序集。

这种方法的好处是，你并不需要在一台机器上安装ASP.NET MVC3，以运行基于ASP.NET MVC3 Web应用程序。

相反，你只要复制你的web应用程序（在bin目录中包含MVC3的组件）到 .NET4服务器上，它就会运行。

这种方法是“完全信任”，“中等信任”的情景（译注：我也不知道是什么意思）

这意味着它甚至可以和低成本共享主机供应商共事。

无需托管服务提供商另外注册/安装/操作需要。

使您的Web项目包含ASP.NET MVC3程序集“bin部署”是非常简单的，

只需2分钟左右。下面是需要遵循的步骤：

Steps to Deploy an ASP.NET MVC 3 Application to a Web Hosting Provider with \Bin deployment

译注：这个链接好像打不开，笔者提供一个方法：

选中ASP.NET MVC引用的程序集，然后查看属性，把“复制到本地”修改为true

asp.net mvc3需要的程序集有

System.Web.Mvc
Microsoft.Web.Infrastructure
System.Web.Razor
System.Web.WebPages
System.Web.WebPages.Razor

一旦配置\BIN部署后，

您使用ASP.NET MVC 3构建的应用程序将在任何安装.NET4的Web服务器上工作。

只需复制到Web服务器，它就会运行。

即使是低成本共享托管账户，你也无需托管服务供应商做任何事。

找一个ASP.NET MVC 3网站托管服务提供商

您可以浏览Windows Web Hosting Gallery（Windows网站托管库）找到所有支持托管服务提供商：

Windows网站托管库允许您通过不同国家和服务水平来筛选/浏览托管服务。

它还能让您轻松过滤“共享主机”，“虚拟主机”和“专用主机”供应商。

“共享主机”是指在你没有管理员权限的远程服务器上，提供单一的Web服务器。
“虚拟主机”供应商在一个远程服务器上提供给你虚拟机 - 通常通过操作系统管理权限和管理的远程终端服务器来访问。

“专用主机”供应商提供您一个完整的物理服务器，通常也提供操作系统的管理员权限和远程终端支持。

基于Windows的网络托管的价格现在是非常符合成本效益的，

共享主机低至$2.75/月，虚拟主机提供的报价$23/月。

上述主机都能通过使用\ bin部署方法来运行ASP.NET MVC 3。

摘要
ASP.NET MVC 3的应用程序可以部署到任何拥有.NET4的Web服务器，

而不必等待托管服务提供商来安装ASP.NET MVC 3组件。

通过\ bin部署ASP.NET MVC3程序集，

只需使用上面的步骤就可转换您的项目，

那么你就可以复制你的应用程序到任何ASP.NET4服务器上。

本文链接

Silverlight企业应用框架设计【六】自定义系统菜单（使用自己的DataForm）

2012-02-03T07:25:00Z

索引

SilverLight企业应用框架设计【五】客户端调用服务端（使用JSON传递数据，自己实现RESTful Web服务）

SilverLight企业应用框架设计【四】实体层设计+为客户端动态生成服务代理(自己实现RiaService)

SilverLight企业应用框架设计【三】服务端设计

SilverLight企业应用框架设计【二】框架画面

SilverLight企业应用框架设计【一】整体说明

首先我们设计的窗体如下

xaml代码如下：

<location:BasePage x:Class="RTMDemo.Frame.Pages.Sys.MenuLE" 
           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"
           mc:Ignorable="d"
           xmlns:dataForm="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data.DataForm.Toolkit"
           xmlns:controls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls"
                   xmlns:toolkit="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Input.Toolkit"
           xmlns:location="clr-namespace:RTMDemo.Frame.Pages"
           xmlns:navigation="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Navigation"
           d:DesignWidth="640" d:DesignHeight="580" xmlns:sdk="http://schemas.microsoft.com/winfx/2006/xaml/presentation/sdk">
    <Grid x:Name="LayoutRoot" Loaded="LayoutRoot_Loaded">
        <Grid.ColumnDefinitions>
            <ColumnDefinition x:Name="CDL" Width="200"/>
            <ColumnDefinition Width="5"/>
            <ColumnDefinition Width="*"/>
        </Grid.ColumnDefinitions>
        <controls:GridSplitter Grid.Column="1"  HorizontalAlignment="Stretch" VerticalAlignment="Stretch"/>
        <ScrollViewer Grid.Row="0" Grid.Column="0" 
                      Width="{Binding ElementName=CDL,Path=Width}" 
                      HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Auto">
            <sdk:TreeView BorderThickness="0" Name="MenuTV" SelectedItemChanged="MenuTV_SelectedItemChanged">
            </sdk:TreeView>
        </ScrollViewer>
        <Grid x:Name="MenuFormG" Grid.Column="2">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="60"></ColumnDefinition>
                <ColumnDefinition Width="8"></ColumnDefinition>
                <ColumnDefinition Width="*"></ColumnDefinition>
            </Grid.ColumnDefinitions>
            <Grid.RowDefinitions>
                <RowDefinition Height="32"></RowDefinition>
                <RowDefinition Height="32"></RowDefinition>
                <RowDefinition Height="32"></RowDefinition>
                <RowDefinition Height="32"></RowDefinition>
                <RowDefinition Height="*"></RowDefinition>
                <RowDefinition Height="32"></RowDefinition>
            </Grid.RowDefinitions>
            <sdk:Label Target="{Binding ElementName=MenuNameTB}"
                       VerticalAlignment="Center" HorizontalAlignment="Right"
                       ></sdk:Label>
            <TextBox Name="MenuNameTB" Grid.Column="2" Grid.Row="0" HorizontalAlignment="Left" Width="300" 
                            VerticalAlignment="Center" Height="22" Text="{Binding MenuName, Mode=TwoWay                
                    ,NotifyOnValidationError=True,ValidatesOnExceptions=True}">
            </TextBox>

            <sdk:Label Grid.Row="1" Target="{Binding ElementName=MenuOrderTB}"
                       VerticalAlignment="Center" HorizontalAlignment="Right"
                       ></sdk:Label>
            <TextBox Name="MenuOrderTB" Grid.Column="2" Grid.Row="1" 
                     HorizontalAlignment="Left" Width="100" 
                        VerticalAlignment="Center" Height="22"     
                        Text="{Binding OrderNum,Mode=TwoWay
                    ,NotifyOnValidationError=True,ValidatesOnExceptions=True}"></TextBox>


            <sdk:Label Grid.Row="2" Content="菜单路径"
                       VerticalAlignment="Center" HorizontalAlignment="Right"
                       ></sdk:Label>
            <ComboBox x:Name="MenuUrlCB" Height="22" Width="300"
                      SelectedValue="{Binding Url,Mode=TwoWay}"
                    Grid.Column="2" Grid.Row="2" HorizontalAlignment="Left"></ComboBox>

            <TextBlock  Grid.Row="3" Text="父级菜单" VerticalAlignment="Center" HorizontalAlignment="Right"></TextBlock>
            <ComboBox Grid.Column="2" Grid.Row="3" DisplayMemberPath="MenuName" x:Name="TMenuCB"
                      Height="22" Width="100"
                    HorizontalAlignment="Left">
            </ComboBox>

            <sdk:Label Grid.Row="4" Target="{Binding ElementName=HelpTB}"
                       VerticalAlignment="Center" HorizontalAlignment="Right"
                       ></sdk:Label>
            <TextBox Grid.Column="2" Grid.Row="4" x:Name="HelpTB"
                            AcceptsReturn="True"
                            TextWrapping="Wrap"
                            VerticalScrollBarVisibility="Auto"
                        Text="{Binding MenuDes,Mode=TwoWay
                    ,NotifyOnValidationError=True,ValidatesOnExceptions=True}"></TextBox>

            <StackPanel Grid.Column="2" Grid.Row="111"  Orientation="Horizontal">
                <Button x:Name="AddBTN" Width="100" Height="22"  Margin="0 0 10 0" Content="增加" Click="AddBTN_Click"></Button>
                <Button x:Name="EditBTN" Width="100" Height="22" Margin="0 0 10 0"  Content="修改" Click="EditBTN_Click"></Button>
                <Button x:Name="DelBTN" Width="100" Height="22" Margin="0 0 10 0"  Content="删除" Click="DelBTN_Click"></Button>
            </StackPanel>
        </Grid>
    </Grid>
</location:BasePage>

需要说明的：

所有的业务窗体都继承自BasePage类

这也是为什么xaml代码的开始处是<location:BasePage….

由于左侧的树控件和右侧的Grid控件中间

有个GridSplitter控件

所以可以自由的拖动GridSplitter控件以变化左右两侧控件的大小

树控件我们暂且不提（没有什么特殊的地方）

-------------------------

在加载页面的Loaded事件中执行了如下代码

private void LayoutRoot_Loaded(object sender, RoutedEventArgs e)
        {            
            if (IsLoaded)
            {
                return;
            }
            InitMenuTree();
            InitTypeCB();
        }

其中IsLoaded属性是基类BasePage的属性

代码如下

protected bool IsLoaded = false;
        public BasePage()
        {
            this.Loaded += new RoutedEventHandler(BasePage_Loaded);
        }
        void BasePage_Loaded(object sender, RoutedEventArgs e)
        {
            IsLoaded = true;
        }

这样做就是为了避免重复执行InitMenuTree和InitTypeCB两个方法的代码

（tab页面切换会触发Loaded事件）

------------------------------------

先来看InitMenuTree的代码

void InitMenuTree()
        {
            var tMenu = Common.ViewUtility.AllMenu
                    .Where(m => m.ParentId == Guid.Empty)
                    .OrderBy(m=>m.OrderNum);
            InitParentMenu(tMenu);
            foreach (var tm in tMenu)
            {
                var ttvi = new TreeViewItem();
                ttvi.Header = tm.MenuName;
                ttvi.DataContext = tm;
                if (MenuTV.Items.Count < 1)
                {
                    MenuFormG.DataContext = tm;
                    ttvi.IsSelected = true;
                }
                ttvi.IsExpanded = true;
                MenuTV.Items.Add(ttvi);
                var sMenu = Common.ViewUtility.AllMenu
                        .Where(m => m.ParentId == tm.Id)
                        .OrderBy(m => m.OrderNum);
                foreach (var sm in sMenu)
                {
                    var stvi = new TreeViewItem();
                    stvi.Header = sm.MenuName;
                    stvi.DataContext = sm;
                    ttvi.Items.Add(stvi);                    
                }
            }
        }

笔者并没有使用数据绑定的形式给控件赋值

而是直接创建了树控件的子控件来赋值的（这与我们的数据结构有关,这样做更简便一些）

MenuM类型并不是一个自引用的类型（没有记录ParentMenu只记录了ParentId）

其中InitParentMenu是初始化下拉框的函数（修改子菜单的父级菜单时用到，这里就不多说了）

/// <summary>
        /// 构造父级菜单的combo box
        /// </summary>
        /// <param name="tMenu"></param>
        void InitParentMenu(IEnumerable<MenuM> tMenu)
        {
            var rs = tMenu.ToList();
            var TM = new MenuM();
            TM.MenuName = "请选择";
            TM.Id = Guid.Empty;
            rs.Insert(0, TM);
            TMenuCB.ItemsSource = rs;
            TMenuCB.SelectedIndex = 0;
        }

-----------------------------------------------

InitTypeCB是构造可以使用的菜单路径（下拉框）的函数

void InitTypeCB()
        {
            var tys = Application.Current.GetType().Assembly.GetTypes().ToList();
            var results = tys.Where(m =>  m.IsPublic 
                                            && m.FullName.StartsWith("RTMDemo.Frame.Pages")
                                            && !m.FullName.EndsWith(".BasePage"))
                             .Select(m=>m.FullName.TrimStart("RTMDemo.Frame.".ToArray()))
                             .ToList();
            results.Insert(0,"请选择");
            MenuUrlCB.ItemsSource = results;
            MenuUrlCB.UpdateLayout();
            MenuUrlCB.SelectedIndex = 0;
        }

此函数反射出了所有业务窗体的类名，并赋值给了一个ComboBox,以供选择

---------------------------------------------------------------

当选中菜单树中的某一项时执行如下事件

private void MenuTV_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
        {
            var item = MenuTV.SelectedItem as TreeViewItem;
            var menuObj = item.DataContext as MenuM;
            var fobj = Common.Utility.DeepCopy(menuObj);
            MenuFormG.DataContext = fobj;
            var parent = Common.ViewUtility.AllMenu
                       .Where(m => m.Id == menuObj.ParentId)
                       .FirstOrDefault();
            TMenuCB.SelectedItem = (parent == null ? TMenuCB.Items.FirstOrDefault() : parent);
            MenuUrlCB.SelectedItem = (string.IsNullOrEmpty(menuObj.Url) ? "请选择" : menuObj.Url);
        }

因为MenuFormG内的数据绑定元素基本上都是使用的双向绑定（更改会直接反应在实体上）

所以我们深拷贝了一个实体提供给表单（这样就不会影响现有实体的数据）

技巧：深拷贝其实就是执行了一次序列化和反序列化的过程

代码如下:

public static object DeepCopy(object tar)
        {
            MemoryStream ms = new MemoryStream();
            var jsonSerializer = new DataContractJsonSerializer(tar.GetType());
            jsonSerializer.WriteObject(ms, tar);
            var result = jsonSerializer.ReadObject(ms);
            return result;
        }

------------------------------------------------------

下面我们来看一下增加一个菜单的方法

private void AddBTN_Click(object sender, RoutedEventArgs e)
        {
            var obj = MenuFormG.DataContext as MenuM;
            if (FormHasError(MenuFormG))
            {
                Common.ViewUtility.Alert("数据有误不能提交");
                return;
            }
            var ms = new MenuService();
            obj.Id = Guid.NewGuid();
            obj.ParentId = (TMenuCB.SelectedItem as MenuM).Id;
            ms.Completed += new ServiceEventHandler((o, se) =>
            {
                Common.ViewUtility.Alert("增加成功");
                Common.ViewUtility.AllMenu.Add(obj);
                Reload();
            });
            ms.AddMenu(obj);
            
        }

验证客户端输入的数据是否正确的方法，是基类提供的

protected bool FormHasError(DependencyObject form)
        {
            var items = form.GetVisuals();
            foreach (var formItem in items)
            {
                if (Validation.GetHasError(formItem))
                {
                    ((Control)formItem).Focus();
                    return true;
                }
            }
            return false;
        }

public static IEnumerable<DependencyObject> GetVisuals(this DependencyObject root)
        {
            int count = VisualTreeHelper.GetChildrenCount(root);
            for (int i = 0; i < count; i++)
            {
                var child = VisualTreeHelper.GetChild(root, i);
                yield return child;
                foreach (var descendants in child.GetVisuals())
                {
                    yield return descendants;
                }
            }
        }

如果某一个菜单项含有错误信息，那么将验证不通过。

Reload方法也是基类提供的

protected void Reload()
        {
            var t = this.GetType();
            var ti = this.Parent as TabItem;
            var menuObj = ti.DataContext as MenuM;
            var tc = ti.Parent as TabControl;
            tc.Items.Remove(ti);

            var obj = Activator.CreateInstance(t);
            ti = new Controls.PageContainer();
            ti.DataContext = menuObj;
            ti.Header = menuObj.MenuName;
            ti.Content = obj;
            tc.Items.Add(ti);
            tc.SelectedItem = ti;
        }

此函数也结合前面的章节来看。

--------------------------------------

至此本系列全部写完了！

源码下载

喜欢的请点推荐，支持我的文章。谢谢各位啦

本文链接

SilverLight企业应用框架设计【五】客户端调用服务端（使用JSON传递数据，自己实现RESTful Web服务）

2012-02-02T12:34:00Z

来个索引

SilverLight企业应用框架设计【四】实体层设计+为客户端动态生成服务代理(自己实现RiaService)

SilverLight企业应用框架设计【三】服务端设计

SilverLight企业应用框架设计【二】框架画面

SilverLight企业应用框架设计【一】整体说明

在上一节中讲到的自动生成的服务代理类核心代码，如下

public event ServiceEventHandler Completed;
        public void GetAllMenu()
        {
            var si = new ServiceInvoker();
            si.Completed += new ServiceEventHandler(si_Completed);
            si.PrepareInvoke("MenuService", "GetAllMenu", typeof(List<MenuM>));
            si.InvokeService();
        }
        void si_Completed(object sender, ServiceEventArgs e)
        {
            Completed(sender, e);
        }

大家注意到我们是通过ServiceInvoker来调用服务的

实例化ServiceInvoker类之后就注册了ServiceEventHandler事件

此事件是服务调用完成后触发的事件（silverlight 原生的ria service也有一个completed事件）

该事件相关代码如下

public class ServiceEventArgs : EventArgs
    {
        //服务方法的返回值
        public object Result { get; set; }
    }
    public delegate void ServiceEventHandler(object sender, ServiceEventArgs e);

在si.PrepareInvoke把需要调用的服务类名，方法名，返回值类型（如果有参数，这里还会自动加入参数）

PrepareInvoke方法如下

public void PrepareInvoke(string ClassName,string MethodName,Type ResultType,params object[] objs)
        {
            className = ClassName;
            methodName = MethodName;
            resultType = ResultType;
            MemoryStream ms = new MemoryStream();
            var sb = new StringBuilder();            
            for(int i=0;i<objs.Length;i++)
            {
                var jsonSerializer = new DataContractJsonSerializer(objs[i].GetType());
                jsonSerializer.WriteObject(ms, objs[i]);
                var objStr = Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length);
                ms.Position = 0;
                sb.AppendFormat("p{0}=", i);
                sb.AppendFormat("{0}", objStr);
                sb.Append("&");
            }
            ms.Close();
            paramStr = sb.ToString();
        }

在此方法中主要是记录下这些信息，

另外把服务需要传入的参数序列化成JSON字符串

紧接着就调用InvokeService方法

代码如下

public void InvokeService()
        {
            Uri serviceUri = new Uri("http://localhost/RTMDemo.Host/RTMDemo.Host.WCF.MenuService");
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(serviceUri);            
            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";
            var requestResult = request.BeginGetRequestStream(new AsyncCallback(RequestReady), request);
            return;
        }

明眼人一看就明了了

其实就是使用HTTPWebRequest来调用服务（服务端我们托管了HttpHandler的请求）

RequestReady事件如下：

void RequestReady(IAsyncResult asyncResult)
        {
            HttpWebRequest request = asyncResult.AsyncState as HttpWebRequest;
            Stream stream = request.EndGetRequestStream(asyncResult);
            Deployment.Current.Dispatcher.BeginInvoke(delegate()
            {
                StreamWriter writer = new StreamWriter(stream);
                writer.Write(paramStr);
                writer.Write("MethodKey=RTMDemo.Host.WCF.{0}.{1}&", className,methodName);
                writer.Flush();
                writer.Close();
                request.BeginGetResponse(new AsyncCallback(ResponseReady), request);
            });
        }

在此事件中我们把服务类名方法名和参数写入了请求流

ResponseReady事件如下

void ResponseReady(IAsyncResult asyncResult)
        {
            HttpWebRequest request = asyncResult.AsyncState as HttpWebRequest;
            HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(asyncResult);
            Deployment.Current.Dispatcher.BeginInvoke(delegate()
            {
                Stream responseStream = response.GetResponseStream();
                if (resultType == null)
                {
                    Completed(this, null);
                    return;
                }
                try
                {
                    DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(resultType);
                    result = jsonSerializer.ReadObject(responseStream);
                }
                catch
                {
                }
                var se = new ServiceEventArgs();
                se.Result = result;
                Completed(this, se);
            });
        }

这个事件把服务端返回的结果（JSON数据）反序列化成实体类型，并赋值给ServiceEventArgs

然后触发了Completed事件

也就是触发我们服务端代理类的si_Completed事件

至此，调用服务端的类就解释完了

下面我们看看是怎么调用服务端的

private void InitMenu()
        {
            var ms = new MenuService();
            ms.Completed += new ServiceEventHandler((o, re) =>
            {                
                var AllMenu = re.Result as List<MenuM>;
                Common.ViewUtility.AllMenu = AllMenu;
                InitTopMenu();
            });
            ms.GetAllMenu();
        }

看看是不是与ria service调用的方法有点像呢？

…………………………………………………………………………喜欢的话……………请推荐吧………………………………………………………

估计再写一篇就完结了

下一篇公布源码

本文链接

SilverLight企业应用框架设计【四】实体层设计+为客户端动态生成服务代理(自己实现RiaService)

2012-02-01T14:00:00Z

题外话：

对不住各位，本打算年前把这个系列写完，结果由于杂务缠身一直推到年后

我特别痛恨我自己！我觉得不但对不起各位！也对不起自己。

最近烦躁不安，不能专心向学。也不知道如何是好。

……

好吧，言归正传

说个前提条件：

此项目虽然使用了silverlight 4.0

但是服务端只能在dotNet3.5下运行

这也是我们为什么自己实现riaService的原因

实体层设计

由于有这个限制条件，我们设计的实体层也有所区别

如下图为实体层的程序集（只有MenuM实体类，其他实体类未加入。）

下面来看一下实体层MenuM的代码

namespace RTMDemo.Model
{
    [DataContract]
    public class MenuM : Entity
    {
        public string _MenuName;
        public string _Url;
        public string _MenuDes;
        public int _OrderNum;
        [DataMember]        
        public Guid Id { get; set; }
        [DataMember]
        [Display(Name = "菜单名称")]
        [Required(ErrorMessage="不能为空")]
        public string MenuName
        {
            get
            {
                return _MenuName;
            }
            set
            {
                ValidateProperty("MenuName", value);
                _MenuName = value;
            }
        }
        [DataMember]
        public Guid ParentId { get; set; }
        [DataMember]
        [Display(Name = "菜单路径")]
        [Required(ErrorMessage = "不能为空")]
        public string Url
        {
            get
            {
                return _Url;
            }
            set
            {
                ValidateProperty("Url", value);
                _Url = value;
            }
        }
        [DataMember]
        [Display(Name = "菜单帮助")]
        public string MenuDes
        {
            get
            {
                return _MenuDes;
            }
            set
            {
                ValidateProperty("Help", value);
                _MenuDes = value;
            }
        }
        [DataMember]
        [Display(Name = "菜单排序")]
        [RegularExpression("[1-9]+[0-9]", ErrorMessage = "只能输入数字")]
        public int OrderNum
        {
            get
            {
                return _OrderNum;
            }
            set
            {
                ValidateProperty("MenuName", value);
                _OrderNum = value;
            }
        }
    }
}

这里有几点需要说明

1：

特性[DataContract]与[DataMember]标记

是为了客户端与服务端传输数据的时候序列化与反序列化引入的

2：

MenuM类继承自Entity类

然而在.net 3.5中是没有Entity类的

那么我们就创建了这个类（就是Attr文件夹下的 Entity.cs类）

namespace System.ServiceModel.DomainServices.Client
{
    [DataContract]
    public class Entity
    {
        public void ValidateProperty(string PropertyName, object value)
        {
        }
    }
}

这个类虽然在这里看上去没什么用

但是在silverlight客户端用处就非常大（等会会说道为silverlight客户端自动生成实体类型，silverlight 4.0是有Entity类的）

3：

[Display(Name = "菜单名称")]

如上：Display特性在dotNet3.5中也是不存在的

同理，我们创建了DisplayAttribute特性，也是为了使用Silverlight4.0的客户端特性

namespace System.ComponentModel.DataAnnotations
{
    public sealed class DisplayAttribute : Attribute
    {
        public string Name { get; set; }
    }
}

为客户端动态生成服务代理和实体类型

使用过Silverlight RIA Service的人一定都知道

每次编译的时候都会在Silverlight程序集中生成如下目录和文件

此文件就包含了服务代理和实体类型

那么为了达到与RIA Service一样的效果

我们为服务端程序集增加了VS2010的后期生成事件命令行

如下图所示

命令行代码为

$(SolutionDir)RTMDemo.Compile\bin\Debug\RTMDemo.Compile.exe

其中

$(SolutionDir)为宏，指解决方案的目录（定义为驱动器 + 路径）；包括尾部的反斜杠“\”。

更多生成事件命令行的宏请参见这里：http://msdn.microsoft.com/zh-cn/library/42x5kfw4(v=vs.90).aspx

这个命令行的意思是

在编译完服务端类库后

执行RTMDemo.Compile\bin\Debug\RTMDemo.Compile.exe

也就是这个类库的生成文件

那么我们来看一下这个程序集中的主要工作

1.保存目录路径以备读取和写入

[DllImport("Kernel32.dll")]
        public static extern string GetCommandLineA();
        //实体的路径
        static string mPath;
        //服务的路径
        static string sPath;
        //客户端的路径
        static string tarPath;
        [STAThread]
        static void Main()
        {
            var rtstr = @"RTMDemo.Compile\bin\Debug\RTMDemo.Compile.exe";
            //获取命令行参数
            var arg = GetCommandLineA().Replace("\"","");
            mPath = arg.Replace(rtstr,"RTMDemo.Model");
            sPath = arg.Replace(rtstr, @"RTMDemo.Host\bin\RTMDemo.Host.dll");
            tarPath = arg.Replace(rtstr, @"RTMDemo.Frame\Generated_Code\RTMDemo.Host.g.cs");

            AddModels();
            AddService();
        }

2.添加实体类型

static void AddModels()
        {
            var di = new DirectoryInfo(mPath);
            var sb = new StringBuilder(Environment.NewLine);
            foreach (var fi in di.GetFiles())
            {
                var pname = Path.GetFileNameWithoutExtension(fi.Name);
                if (!pname.EndsWith("M"))
                {
                    continue;
                }
                var sr = new StreamReader(fi.FullName);
                var content = sr.ReadToEnd();
                var matche = Regex.Match(content, @"\[DataContract(.|\n)*}");
                var str = matche.Value;
                str = str.TrimEnd('}');
                sb.Append(Environment.NewLine);
                sb.AppendFormat("    {0}", str);
                sr.Close();
            }
            sb.Append(Environment.NewLine);
            WriteToTar("实体", sb.ToString());
        }

此端代码大意为：

遍历实体类库文件夹内的文件，

读取文件名以M结尾的文件（约定实体类名必须以M结尾）

然后按正则匹配[DataContract]以后的内容

把这些内容保存起来以备写入目标文件

3.添加服务代理

static void AddService()
        {
            
            var ass = Assembly.LoadFile(sPath);
            var types = ass.GetTypes();
            var sb = new StringBuilder(Environment.NewLine);
            foreach (var ty in types)
            {
                if (!ty.Name.EndsWith("Service"))
                {
                    continue;
                }
                sb.AppendLine(string.Format("public class {0}", ty.Name));
                sb.AppendLine("{");
                sb.AppendLine("public event ServiceEventHandler Completed;");
                var methods = ty.GetMethods();
                foreach (var me in methods)
                {
                    if (me.DeclaringType != ty)
                    {
                        continue;
                    }
                    sb.AppendFormat("public void {0}(", me.Name);
                    var Parameters = me.GetParameters();
                    var ps = new StringBuilder();
                    for (var i = 0; i < Parameters.Length; i++)
                    {
                        var tn = GetTypeName(Parameters[i].ParameterType);
                        var dh = (i == Parameters.Length - 1?"":",");
                        sb.AppendFormat("{0} {1}{2}", tn, Parameters[i].Name,dh);
                        ps.AppendFormat(" ,{0}", Parameters[i].Name);
                    }
                    sb.AppendFormat("){0}", Environment.NewLine);
                    sb.AppendLine("{");
                    sb.AppendLine("var si = new ServiceInvoker();");
                    sb.AppendLine("si.Completed += new ServiceEventHandler(si_Completed);");
                    var rtp = GetTypeName(me.ReturnType);
                    if (rtp == "Void")
                    {
                        sb.AppendLine(string.Format("si.PrepareInvoke(\"{0}\", \"{1}\", {2} {3});",
                            ty.Name, me.Name, "null", ps.ToString()));
                    }
                    else
                    {
                        sb.AppendLine(string.Format("si.PrepareInvoke(\"{0}\", \"{1}\", typeof({2}) {3});", 
                                    ty.Name, me.Name, rtp, ps.ToString()));
                    }
                    sb.AppendLine("si.InvokeService();");
                    sb.AppendLine("}");
                }
                sb.AppendLine("void si_Completed(object sender, ServiceEventArgs e)");
                sb.AppendLine("{");
                sb.AppendLine("Completed(sender, e);");
                sb.AppendLine("}");
                sb.AppendLine("}");
            }
            sb.Append(Environment.NewLine);
            WriteToTar("服务", sb.ToString());
        }

获取服务端类信息与获取实体类信息不同

获取服务端类信息使用了反射

我们反射出类的名字，类中的方法名，参数名，参数类型，返回值类型等

来生成形如下面这样的服务端代理

public class MenuService
    {
        public event ServiceEventHandler Completed;
        public void GetAllMenu()
        {
            var si = new ServiceInvoker();
            si.Completed += new ServiceEventHandler(si_Completed);
            si.PrepareInvoke("MenuService", "GetAllMenu", typeof(List<MenuM>));
            si.InvokeService();
        }
        public void DelMenu(Guid Id)
        {
            var si = new ServiceInvoker();
            si.Completed += new ServiceEventHandler(si_Completed);
            si.PrepareInvoke("MenuService", "DelMenu", null, Id);
            si.InvokeService();
        }
        public void AddMenu(MenuM m)
        {
            var si = new ServiceInvoker();
            si.Completed += new ServiceEventHandler(si_Completed);
            si.PrepareInvoke("MenuService", "AddMenu", null, m);
            si.InvokeService();
        }
        public void UpdateMenu(MenuM m)
        {
            var si = new ServiceInvoker();
            si.Completed += new ServiceEventHandler(si_Completed);
            si.PrepareInvoke("MenuService", "UpdateMenu", null, m);
            si.InvokeService();
        }
        void si_Completed(object sender, ServiceEventArgs e)
        {
            Completed(sender, e);
        }
    }

至于ServiceInvoker是什么，我们将在下一节内容中介绍

注意：这样生成服务端代理暂不支持生成服务端方法的重载代理

在获取参数或返回值类型的时候，

会遇到获取泛型类型的情况（如：List~<….>，就不能把这些拼到字符串内去）

我们使用诸如下面的函数来做简单判别

public static string GetTypeName(Type t)
        {
            if (t.Name.StartsWith("List"))
            {
                var gtype = t.GetGenericArguments().FirstOrDefault();
                var result = string.Format("List<{0}>", gtype.Name);
                return result;
            }
            return t.Name;
        }

4.写入代理文件

原始的代理文件模版如下

//------------------------------------------------------------------------------
// <auto-generated>
//     此代码由工具生成。
//     对此文件的更改可能会导致不正确的行为，
//     并且如果重新生成代码，这些更改将会丢失。
// </auto-generated>
//------------------------------------------------------------------------------

namespace RTMDemo.Frame.Client
{
    using System;
    using System.Collections.Generic;
    using System.Runtime.Serialization;
    using RTMDemo.Frame.Common;
    using System.ComponentModel.DataAnnotations;
    using System.ComponentModel;
    using System.ServiceModel.DomainServices.Client;
    #region 实体

    #endregion

    #region 服务


    #endregion
}

写入代理文件主要是匹配两个region

然后插入之前生成的字符串

static void WriteToTar(string reg, string content)
        {
            reg = string.Format(@"(?<=#region {0})(.|\n)*?(?=#endregion)", reg);
            var tsr = new StreamReader(tarPath);
            var tcontent = tsr.ReadToEnd();
            tsr.Close();
            tcontent = Regex.Replace(tcontent, reg, content);
            var tarStream = new StreamWriter(tarPath);
            tarStream.Write(tcontent);
            tarStream.Close();
        }

调用此函数的代码如下

WriteToTar("服务", sb.ToString());

至此就把服务代理和实体类型都拷贝到客户端去了

在下一节我们介绍怎么使用这些内容

………………………………………….写文章不容易…………………请务必点个推荐吧………………………………………………

本文链接

【翻译】.NET Framework 4.5新特性

2012-01-09T05:54:00Z

开发者预览版.net 4.5

.NET for Metro style apps
Metro风格的应用程序是利用Windows操作系统的强大功能设计的特殊表单元素。
一个称之为.NET APIs for Metro style apps的.Net的一个子集用来支持Metro风格的应用程序，
可以使用C#或Visual Basic来编写Metro风格的应用程序。
详见：
http://go.microsoft.com/fwlink/?LinkId=228491

核心新功能和改进
以下这些功能和改进被添加到公共语言运行时（CLR）和.NET的类内：
-设置正则表达式执行匹配的超时时间
-为应用程序域设置区域性信息
-控制台应用支持Unicode（UTF-16）编码
-支持按区域信息进行字符串比较和排序
-提高了检索资源的性能
-Zip压缩的改进，以减少一个压缩文件的大小
-可以使用CustomReflectionContext类来自定义一个反射的上下文，以重写默认的反射行为
（关于CustomReflectionContext类的信息，详见：http://msdn.microsoft.com/zh-cn/library/system.reflection.context.customreflectioncontext(v=VS.110).aspx）

Managed Extensibility Framework (MEF)
-支持泛型类型
-“约定优先”的编程模型。（你可以不必使用类特性来创建部件，现在可以按命名约定来创建你的部件）
-多作用域

异步文件操作
在.NET框架4.5开发者预览版中，
基于任务模型的异步操作特性被添加到C#和Visual Basic语言。
使用asynchronous methods in the I/O classes可以使用这些新特性

Web
ASP.NET4.5开发预览版包括以下新的特点：
-
支持新的HTML5表单类型。
-
支持在Web Forms中进行模型绑定。
可以直接把数据访问方法绑定到控件上
可以自动把用户输入的数据进行格式转化
-
Support for unobtrusive JavaScript in client-side validation scripts
（这一句不知道怎么翻~我也不明白这一句是什么意思.）
-
通过捆绑和压缩客户端脚本以提高性能
-
使用AntiXSS库对常规的表单进行编码，以防止跨站脚本攻击
AntiXSS以前是一个外部类库，还包括SQL注入防御；详见：http://wpl.codeplex.com/
-
支持的WebSockets协议
（这应该是HTML5的内容，详见：http://en.wikipedia.org/wiki/Web_Sockets）
-
支持异步读写HTTP的请求和响应
-
支持异步modules和handlers
-
使用ScriptManager支持内容分发网络（CDN）
更多功能：
http://msdn.microsoft.com/zh-cn/library/hh420390(v=VS.110).aspx

Networking 网络
NET Framework4.5开发人员预览版提供了HTTP应用新的编程接口。
更多详细信息，
请见新版 System.Net.Http
（http://msdn.microsoft.com/zh-cn/library/system.net.http(v=VS.110).aspx）
和 System.Net.Http.Headers
（http://msdn.microsoft.com/zh-cn/library/system.net.http.headers(v=VS.110).aspx）
命名空间。
此外，下面的网络方面的改进包括System.Net，System.Net.Mail，以及相关的命名空间。
-改进的国际化和IPv6支持。
-RFC兼容的URI支持。
-支持国际域名（IDN）分析。
-电子邮件地址国际化（EAI）的支持。

Windows Presentation Foundation (WPF)
在.NET框架4.5开发人员预览版中，Windows Presentation Foundation（WPF）包含以下几个方面的变化和改进：
-新的ribbon控件
-新INotifyDataErrorInfo接口，支持同步和异步数据验证
-VirtualizingPanel和Dispatcher类的新功能。
-显示大集合数据和非UI线程访问集合时的性能改进
-绑定到静态属性与绑定到自定义类型都实现了ICustomTypeProvider接口，从绑定表达式提取数据绑定信息
-对变化的值进行复位 (live shaping).
-更好的集成WPF和Win32的用户界面组件。
-可以检查容器的数据上下文是否断开链接。
-可以设置属性、数据源改变的超时时间
-实施弱事件模式的改进支持。此外，事件现在可以接受的扩展标记。
欲了解更多信息：http://msdn.microsoft.com/zh-cn/library/bb613588(v=VS.110).aspx

Windows Communication Foundation (WCF)
-简化生成的配置文件
-契约优先原则开发支持。
-更容易的配置ASP.NET兼容性模式。
-修改了默认传输属性，以减少开发人员通过编码设置它的次数。
-更新的XmlDictionaryReaderQuotas类，以减少手动配置XML字典的读者配额的次数。
-VisualStudio可以在编译时验证WCF配置文件是否正确，这样就避免了运行之后才能发现配置文件错误的问题。
-新的异步流支持。
-新的HTTPS协议映射，使IIS上的基于HTTPS协议的WCF服务更容易暴露终结点
-通过在WCF服务URL中增加“?singleWSDL”可以生成WSDL元数据
-WebSockets的支持，使得在80和443端口的双向通信方式与TCP传输类似。
-支持在代码中配置服务（应该是运行期改变服务配置）
-XML编辑器提示。
-ChannelFactory的缓存支持。
-二进制编码压缩的支持
更多：
http://go.microsoft.com/fwlink/?LinkId=228173

原文地址

http://msdn.microsoft.com/library/ms171868%28VS.110%29.aspx#tailored

由于我对WF部分不熟

就没有翻译这一部分

-------------------------------------------------------------支持的请点推荐啊！！！---------------------------------------------------

本文链接

SilverLight企业应用框架设计【三】服务端设计

2012-01-05T13:45:00Z

一：缓存服务类型与方法

客户端请求的时候

为了方便的知道请求的类型与类型所包含的方法

我们把服务类型和方法缓存到静态字典中了

代码如下

public class WCFRouteTable
    {
        static Dictionary<string, Type> routeService;
        static Dictionary<string, MethodInfo> routeMethods;
        static WCFRouteTable()
        {
            routeService = new Dictionary<string, Type>();
            routeMethods = new Dictionary<string, MethodInfo>();
            var ass = (typeof(WCFRouteTable)).Assembly;
            var ts = ass.GetTypes();
            foreach (var t in ts)
            {
                if (t.FullName.StartsWith("RTMDemo.Host.WCF"))
                {
                    routeService.Add(t.FullName, t);
                    foreach (var m in t.GetMethods())
                    {
                        var mName = string.Format("{0}.{1}", t.FullName, m.Name);
                        routeMethods.Add(mName, m);
                    }
                }
            }
        }
        public static Type GetWCFType(string key)
        {
            Type result = null;
            if (routeService.ContainsKey(key))
            {
                result = routeService[key];
            }
            return result;
        }
        public static MethodInfo GetMethodInfo(string key)
        {
            MethodInfo result = null;
            if (routeMethods.ContainsKey(key))
            {
                result = routeMethods[key];
            }
            return result;
        }

    }

二：托管HTTP请求

在webconfig中增加module以托管请求

<modules>
            <add name="WcfHttpModule" type="RTMDemo.Host.WCFHttpModule, RTMDemo.Host"/>
    </modules>

托管请求对应的类的代码如下

public class WCFHttpModule:IHttpModule
    {
        public void Dispose() { }
        /// <summary>
        /// 托管请求
        /// </summary>
        /// <param name="context"></param>
        public void Init(HttpApplication context)
        {
            context.BeginRequest += (sender, args) =>
            {
                string relativeAddress = HttpContext.Current.Request.AppRelativeCurrentExecutionFilePath.Remove(0, 2);
                Type serviceType = WCFRouteTable.GetWCFType(relativeAddress);
                if (null == serviceType)
                {
                    return;
                }
                IHttpHandler handler = new WCFHandler(serviceType);
                context.Context.RemapHandler(handler);
            };
        }
    }

通过这行代码

Type serviceType = WCFRouteTable.GetWCFType(relativeAddress);

用户只要请求如下路径

http://localhost/RTMDemo.Host/RTMDemo.Host.WCF.MenuService

就会得到MenuService的类型

然后把服务类型传给指定的处理程序

三：处理请求

在WCFHandler类中最重要的莫过于

处理请求的方法

代码如下

/// <summary>
        /// 处理请求
        /// </summary>
        /// <param name="context"></param>
        public void ProcessRequest(HttpContext context)
        {
            try
            {
                List<object> paramList = new List<object>();
                JavaScriptSerializer jss = new JavaScriptSerializer();
                var MethodKey = context.Request["MethodKey"];
                var minfo = WCFRouteTable.GetMethodInfo(MethodKey);
                var si = new MethodInvoker(minfo);
                ParameterInfo[] ps = minfo.GetParameters();
                var pstrs = context.Request.Form.AllKeys.OrderBy(m=>m).ToArray();
                var pIndex = 0;
                for(var i=0;i<pstrs.Length;i++)
                {
                    if (string.IsNullOrEmpty(pstrs[i]))
                    {
                        continue;
                    }
                    if (pstrs[i].StartsWith("p"))
                    {
                        var pStr = context.Request[pstrs[i]];
                        var obj = jss.Deserialize<object>(pStr);
                        var bts = Encoding.UTF8.GetBytes(pStr);
                        MemoryStream mss = new MemoryStream(Encoding.UTF8.GetBytes(pStr));
                        DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(ps[pIndex].ParameterType);                
                        var p = jsonSerializer.ReadObject(mss);
                        paramList.Add(p);
                        pIndex += 1;
                    }
                }

                //todo:此处性能不佳
                var instance = Activator.CreateInstance(ServiceType);
                var result = si.Execute(instance,paramList.ToArray());
                var ss = jss.Serialize(result);

                context.Response.ClearContent();
                context.Response.ContentEncoding = Encoding.UTF8;
                context.Response.ContentType = "application/json; charset=utf-8";
                context.Response.Write(ss);
                context.Response.Flush();
            }
            catch
            {
                context.Response.Write("我们不提供此服务的元数据~<br />");
                context.Response.Write("@@@@@@~<br />@@@@@@@~");
                return;
            }
        }
    }

注意：首先说这段代码还有很大的优化空间；也未经过严格的测试；但思路基本就是这样的

处理请求主要做了如下几步工作：

先根据请求POST上来的信息得到准备执行的方法

var MethodKey = context.Request["MethodKey"];
var minfo = WCFRouteTable.GetMethodInfo(MethodKey);

MethodInvoker稍后再讲

按顺序取出了方法的参数，并用DataContractJsonSerializer反序列化成对象

方法参数都是用JSON字符串传递的

通过反射创建了服务的实例

然后调用该实例的方法

得到方法的返回值，并序列化成JSON字符串

把返回值以JSON的形式输出给客户端

四：其他

MethodInvoker是用的老赵的类；具体是哪篇文章，我已经找不到了。

public class MethodInvoker
    {
        private Func<object, object[], object> m_execute;

        public MethodInvoker(MethodInfo methodInfo)
        {
            this.m_execute = this.GetExecuteDelegate(methodInfo);
        }

        public object Execute(object instance, params object[] parameters)
        {
            return this.m_execute(instance, parameters);            
        }

        private Func<object, object[], object> GetExecuteDelegate(MethodInfo methodInfo)
        {
            ParameterExpression instanceParameter = Expression.Parameter(typeof(object), "instance");
            ParameterExpression parametersParameter = Expression.Parameter(typeof(object[]), "parameters");

            List<Expression> parameterExpressions = new List<Expression>();
            ParameterInfo[] paramInfos = methodInfo.GetParameters();
            for (int i = 0; i < paramInfos.Length; i++)
            {
                var ce = Expression.Constant(i);
                BinaryExpression valueObj = Expression.ArrayIndex(parametersParameter,ce);
                UnaryExpression valueCast = Expression.Convert(valueObj, paramInfos[i].ParameterType);
                parameterExpressions.Add(valueCast);
            }
            var instanceE = Expression.Convert(instanceParameter, methodInfo.ReflectedType);
            Expression instanceCast = methodInfo.IsStatic ? null : instanceE;
            MethodCallExpression methodCall = Expression.Call(instanceCast, methodInfo, parameterExpressions);
            if (methodCall.Type == typeof(void))
            {
                Expression<Action<object, object[]>> lambda = Expression.Lambda<Action<object, object[]>>(methodCall, instanceParameter, parametersParameter);
                Action<object, object[]> execute = lambda.Compile();
                return (instance, parameters) =>
                {
                    execute(instance, parameters);
                    return null;
                };
            }
            else
            {
                UnaryExpression castMethodCall = Expression.Convert(methodCall, typeof(object));
                Expression<Func<object, object[], object>> lambda =Expression.Lambda<Func<object, object[], object>>(castMethodCall, instanceParameter, parametersParameter);
                return lambda.Compile();
            }
        }
    }

服务类和数据访问的类没有什么特殊的

我这里只公布一个服务的类

public class MenuService
    {
        public List<MenuM> GetAllMenu()
        {            
            using (var DA = new MenuDA())
            {
                var result = DA.GetAllMenu();
                return result;
            }
        }
        public void DelMenu(Guid Id)
        {
            using (var DA = new MenuDA())
            {
                DA.DelMenu(Id);
            }
        }
        public void AddMenu(MenuM m)
        {
            using (var DA = new MenuDA())
            {
                DA.AddMenu(m);
            }
        }
        public void UpdateMenu(MenuM m)
        {
            using (var DA = new MenuDA())
            {
                DA.UpdateMenu(m);
            }
        }
    }

MenuDa就是数据访问类了

很普通，就不在公布代码了

完成这些工作之后

我们只要在客户端构造好表单

然后把表单POST到指定的路径

就能完成服务的访问了！

---------------------------------------------------------------

喜欢的话~请大家推荐我的文章

谢谢~

我真的很需要你们的支持

本文链接

SilverLight企业应用框架设计【二】框架画面

2012-01-04T13:31:00Z

框架画面分为上中下三层

由下面一个Grid控件完成布局

<Grid x:Name="LayoutRoot">
        <Grid.RowDefinitions>
            <RowDefinition Height="60"></RowDefinition>
            <RowDefinition Height="*"></RowDefinition>
            <RowDefinition Height="22"></RowDefinition>
        </Grid.RowDefinitions>
       </Grid>

上层为顶部菜单区域

中层为子菜单和业务画面部分

下层为状态栏和版权信息区域

下面我们分别看一下这三个部分的生成逻辑

一：顶部菜单区域

XAML代码如下：

<StackPanel x:Name="TopMenuS" Orientation="Horizontal" Background="{StaticResource HeadBG}">
            <Grid>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="10"></ColumnDefinition>
                    <ColumnDefinition Width="142"></ColumnDefinition>
                    <ColumnDefinition Width="10"></ColumnDefinition>
                </Grid.ColumnDefinitions>
                <Grid.RowDefinitions>
                    <RowDefinition Height="3"></RowDefinition>
                    <RowDefinition Height="18"></RowDefinition>
                    <RowDefinition Height="18"></RowDefinition>
                    <RowDefinition Height="18"></RowDefinition>
                    <RowDefinition Height="3"></RowDefinition>
                </Grid.RowDefinitions>
                <TextBlock x:Name="helloBlock" Grid.Column="1" Grid.Row="1" Text="xxxx通信" />
                <TextBlock x:Name="UserName" Text="Administrator" Grid.Column="1" Grid.Row="2" />
                <TextBlock Text="欢迎使用 xxx监控系统" Grid.Column="1" Grid.Row="3" />
            </Grid>
            <Rectangle Width="1" Fill="{StaticResource HeadSplitor}"></Rectangle>                        
            <StackPanel>
                <Button Style="{StaticResource ToolBtnStyle}" Content="全部关闭" Click="CloseAllClick"></Button>
                <Button Style="{StaticResource ToolBtnStyle}" Content="关闭当前" Click="CloseCurClick"></Button>
                <Button Style="{StaticResource ToolBtnStyle}" Content="关闭其他" Click="CloseOtherClick"></Button>
            </StackPanel>
            <Rectangle Width="1" Fill="{StaticResource HeadSplitor}"></Rectangle>
            <StackPanel>
                <Button Style="{StaticResource ToolBtnStyle}" Content="修改密码" Click="ChangePSWBtnClick"></Button>
                <Button Style="{StaticResource ToolBtnStyle}" Content="退出系统" Click="LoginOutBtnClick"></Button>
                <Button Style="{StaticResource ToolBtnStyle}" Content="重新登录" Click="ReLoginBtnClick"></Button>
            </StackPanel>
            <Rectangle Width="1" Fill="{StaticResource HeadSplitor}"></Rectangle>
        </StackPanel>

顶部菜单分为三部分

从左向右依次是

欢迎信息（GRID）

顶部菜单（动态创建）

常用按钮（StackPanel)

顶部菜单的容器是一个StackPanel

此容器有一个渐变的背景色，样式代码如下

<!--头部渐变背景-->
    <LinearGradientBrush x:Key="HeadBG" StartPoint="0.5 0" EndPoint="0.5 1">
        <GradientStop Offset="0" Color="#FAFAFA"></GradientStop>
        <GradientStop Offset="0.5" Color="#D6D6D6"></GradientStop>
    </LinearGradientBrush>

此容器每个部分都有一个Rectangle来分割

此Rectangle也有个渐变的背景，代码如下

<!--头部分隔条渐变背景-->
    <LinearGradientBrush x:Key="HeadSplitor" StartPoint="0.5 0" EndPoint="0.5 1">
        <GradientStop Offset="0" Color="#FAFAFA"></GradientStop>
        <GradientStop Offset="1" Color="#000000"></GradientStop>
    </LinearGradientBrush>

常用按钮的样式如下：

<!--头部的 三分栏  工具按钮样式-->
    <Style x:Key="ToolBtnStyle" TargetType="Button">
        <Style.Setters>
            <Setter Property="Width" Value="90"></Setter>
            <Setter Property="Height" Value="20"></Setter>
            <Setter Property="Cursor" Value="Hand"></Setter>
            <Setter Property="Template">
                <Setter.Value>
                    <ControlTemplate TargetType="Button">
                        <Grid x:Name="Container">
                            <vsm:VisualStateManager.VisualStateGroups>
                                <vsm:VisualStateGroup x:Name="CommonStates">
                                    <vsm:VisualState x:Name="MouseOver">
                                        <Storyboard>
                                            <DoubleAnimation Storyboard.TargetName="fillColor" Storyboard.TargetProperty="Opacity" Duration="0" To="1"/>
                                        </Storyboard>
                                    </vsm:VisualState>
                                    <vsm:VisualState x:Name="Normal" />
                                </vsm:VisualStateGroup>
                            </vsm:VisualStateManager.VisualStateGroups>
                            <Rectangle x:Name="fillColor" Opacity="0" Fill="#B5B5B5"  IsHitTestVisible="False" RadiusX="1" RadiusY="1"/>
                            <ContentPresenter                                
    			                x:Name="contentPresenter"
    			                Content="{TemplateBinding Content}"
    			                ContentTemplate="{TemplateBinding ContentTemplate}"
    			                VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
    			                HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
    			                Margin="{TemplateBinding Padding}"/>
                        </Grid>
                    </ControlTemplate>
                </Setter.Value>
            </Setter>
        </Style.Setters>
    </Style>

动态创建顶部菜单的代码如下

（大家先不要深究数据是怎么来的，在以后的章节咱们会讲到数据交互的细节）

var tops = Common.ViewUtility.AllMenu
                .Where(m => m.ParentId == Guid.Empty)
                .OrderByDescending(m => m.MenuOrder);
            foreach (var m in tops)
            {
                var topM = new HeadBtn();
                topM.DataContext = m;
                topM.MouseLeftButtonUp += new MouseButtonEventHandler(topM_MouseLeftButtonUp);
                TopMenuS.Children.Insert(2,topM);
            }

这里创建的HeadBtn是一个自定义的控件

（每个顶部菜单就是一个控件的实例）

该自定义控件XAML代码如下：

<StackPanel Orientation="Horizontal" Cursor="Hand">
        <Grid x:Name="btn" Width="90" Height="60">
            <Grid.RowDefinitions>
                <RowDefinition></RowDefinition>
                <RowDefinition Height="20"></RowDefinition>
            </Grid.RowDefinitions>
            <Image Source="../Images/module2.png" Height="30"></Image>
            <TextBlock Text="{Binding MenuName}" Grid.Row="1" FontSize="12"
                       VerticalAlignment="Center" HorizontalAlignment="Center" ></TextBlock>
        </Grid>
        <Rectangle Width="1" Fill="{StaticResource HeadSplitor}"></Rectangle>
    </StackPanel>

注意，这里每个顶部菜单的ICO图标不是动态的，朋友们，想让他变成动态的就自己动手吧

为了实现美观的效果

我为这个自定义控件定义了鼠标的滑入滑出事件

private void UserControl_MouseEnter(object sender, MouseEventArgs e)
        {
            var color = Color.FromArgb(255,180, 180, 180);
            btn.Background = new SolidColorBrush(color);
        }
        private void UserControl_MouseLeave(object sender, MouseEventArgs e)
        {
            btn.Background = new SolidColorBrush(Colors.Transparent);
        }

这些颜色的值，本应该作为资源放在样式文件中，我这里也没有做处理

二：底部状态条区域

此处比较简单

代码如下：

<StackPanel Width="Auto" Grid.Row="2" 
                    Background="#B5B5B5" Orientation="Horizontal" FlowDirection="RightToLeft">
            <TextBlock VerticalAlignment="Center" Text="V1.0.0 Copy Right © All Rights Reserved"/>
            <TextBlock VerticalAlignment="Center"  Text="xxxx"/>
        </StackPanel>

1.我没有做状态信息的内容

2.版本信息应该通过Assambly获取

三：中部区域

XAML代码如下

<Border  Grid.Row="1" BorderBrush="#B5B5B5" BorderThickness="0 1 0 0">
            <Grid  Background="#E8E8E8" Margin="0 1 0 0" Name="CenterGrid">
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="160"></ColumnDefinition>
                    <ColumnDefinition Width="*"></ColumnDefinition>
                </Grid.ColumnDefinitions>
                <StackPanel>
                    <sdk:Label  Height="26"  Background="#b5b5b5"  Margin="0 6 0 6"
                                FontWeight="Bold" FontSize="12" x:Name="lblMenuText" 
                                HorizontalAlignment="Center"  Width="160"  />
                    <ListBox  SelectionChanged="left_panel_SelectionChanged"  
                               ItemContainerStyle="{StaticResource ListBoxItemStyleNew}"
                               Grid.Column="0" x:Name="left_panel" Background="#E8E8E8" BorderThickness="0">
                        <ListBox.ItemTemplate>
                            <DataTemplate>
                                <ContentPresenter Content="{Binding MenuName}"></ContentPresenter>
                            </DataTemplate>
                        </ListBox.ItemTemplate>
                    </ListBox>
                </StackPanel>
                <sdk:TabControl x:Name="tbControl" SelectionChanged="tbControl_SelectionChanged" Grid.Column="1" Margin="0 6 0 0">
                </sdk:TabControl>
            </Grid>
        </Border>

其中Label控件显示的为顶部菜单的标题，标志着当前选中的是哪个顶部菜单

ListBox为子菜单控件

TabControl为业务画面区域

四：子菜单区域

子菜单样式相对复杂些

样式代码如下

<!--子菜单样式-->
    <Style TargetType="ListBoxItem" x:Key="ListBoxItemStyleNew" >
        <Setter Property="Padding" Value="3" />
        <Setter Property="HorizontalContentAlignment" Value="Center" />
        <Setter Property="VerticalContentAlignment" Value="Center" />
        <Setter Property="Background" Value="Transparent" />
        <Setter Property="BorderThickness" Value="1"/>
        <Setter Property="TabNavigation" Value="Local" />
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="ListBoxItem">
                    <Grid Background="{TemplateBinding Background}">
                        <vsm:VisualStateManager.VisualStateGroups>
                            <vsm:VisualStateGroup x:Name="CommonStates">
                                <vsm:VisualState x:Name="Normal" />
                                <vsm:VisualState x:Name="MouseOver">
                                    <Storyboard>
                                        <DoubleAnimation Storyboard.TargetName="fillColor" Storyboard.TargetProperty="Opacity" Duration="0" To=".35"/>
                                    </Storyboard>
                                </vsm:VisualState>
                                <vsm:VisualState x:Name="Disabled">
                                    <Storyboard>
                                        <DoubleAnimation Storyboard.TargetName="contentPresenter" Storyboard.TargetProperty="Opacity" Duration="0" To=".55" />
                                    </Storyboard>
                                </vsm:VisualState>
                            </vsm:VisualStateGroup>
                            <vsm:VisualStateGroup x:Name="SelectionStates">
                                <vsm:VisualState x:Name="Unselected" />
                                <vsm:VisualState x:Name="Selected">
                                    <Storyboard>
                                        <DoubleAnimation Storyboard.TargetName="fillColor2" Storyboard.TargetProperty="Opacity" Duration="0" To=".75"/>
                                    </Storyboard>
                                </vsm:VisualState>
                            </vsm:VisualStateGroup>
                            <vsm:VisualStateGroup x:Name="FocusStates">
                                <vsm:VisualState x:Name="Focused">
                                    <Storyboard>
                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="FocusVisualElement" Storyboard.TargetProperty="Visibility" Duration="0">
                                            <DiscreteObjectKeyFrame KeyTime="0">
                                                <DiscreteObjectKeyFrame.Value>
                                                    <Visibility>Visible</Visibility>
                                                </DiscreteObjectKeyFrame.Value>
                                            </DiscreteObjectKeyFrame>
                                        </ObjectAnimationUsingKeyFrames>
                                    </Storyboard>
                                </vsm:VisualState>
                                <vsm:VisualState x:Name="Unfocused"/>
                            </vsm:VisualStateGroup>
                        </vsm:VisualStateManager.VisualStateGroups>
                        <Rectangle x:Name="fillColor" Opacity="0" Fill="#B5B5B5"  IsHitTestVisible="False" RadiusX="1" RadiusY="1"/>
                        <Rectangle x:Name="fillColor2" Opacity="0" Fill="#FFBADDE9" IsHitTestVisible="False" RadiusX="1" RadiusY="1"/>
                        <ContentPresenter
                              x:Name="contentPresenter"
                                Cursor="Hand"
                              Content="{TemplateBinding Content}"
                              ContentTemplate="{TemplateBinding ContentTemplate}"
                              HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
                              Margin="{TemplateBinding Padding}"/>
                        <Rectangle x:Name="FocusVisualElement" Stroke="#FF6DBDD1" StrokeThickness="1" Visibility="Collapsed" RadiusX="1" RadiusY="1" />
                    </Grid>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>

这些样式主要是为了实现如下效果

子菜单数据绑定非常简单

（顶部菜单的单击事件将绑定子菜单）

代码如下：

void topM_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            var tBTN = sender as HeadBtn;
            var tMenu = tBTN.DataContext as MenuM;
            lblMenuText.Content = tMenu.MenuName;
            var subs = Common.ViewUtility.AllMenu
                .Where(m => m.ParentId == tMenu.Id)
                .OrderBy(m => m.MenuOrder);
            left_panel.ItemsSource = subs;
        }

五：业务画面区域

业务画面的容器为TabControl

每个TabItem将承载一个业务画面

主要是为TabItem增加关闭按钮

XAML代码如下：

<sdk:TabItem.HeaderTemplate>
        <DataTemplate>
            <StackPanel Orientation="Horizontal" Width="auto" Margin="0 0 -2 -2">
                <TextBlock  x:Name="tboxheader" Text="{Binding}"/>
                <Button Cursor="Hand" Click="CloseBTN_Click" Style="{StaticResource ListViewHeadBtnStyle}" Margin="3,-3,-6,0"  Content="X" >
                </Button>
            </StackPanel>
        </DataTemplate>
    </sdk:TabItem.HeaderTemplate>
    </sdk:TabItem>

这个关闭按钮的样式比较特殊

<!--标签按钮-->
    <Style x:Key="ListViewHeadBtnStyle" TargetType="Button">
        <Style.Setters>
            <Setter Property="Width" Value="20"></Setter>
            <Setter Property="Height" Value="20"></Setter>
            <Setter Property="Template">
                <Setter.Value>
                    <ControlTemplate TargetType="Button">
                        <Grid  x:Name="Container">
                            <vsm:VisualStateManager.VisualStateGroups>
                                <vsm:VisualStateGroup x:Name="CommonStates">
                                    <vsm:VisualState x:Name="Normal" />
                                    <vsm:VisualState x:Name="MouseOver">
                                        <Storyboard>
                                            <DoubleAnimation Storyboard.TargetName="fillColor" Storyboard.TargetProperty="Opacity" Duration="0" To=".35"/>
                                        </Storyboard>
                                    </vsm:VisualState>
                                </vsm:VisualStateGroup>
                            </vsm:VisualStateManager.VisualStateGroups>
                            <Rectangle x:Name="fillColor" Opacity="0" Fill="#B5B5B5"  IsHitTestVisible="False" RadiusX="1" RadiusY="1"/>
                            <ContentPresenter                                
    			                x:Name="contentPresenter"
    			                Content="{TemplateBinding Content}"
    			                ContentTemplate="{TemplateBinding ContentTemplate}"
    			                VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
    			                HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
    			                Margin="{TemplateBinding Padding}"/>
                        </Grid>
                    </ControlTemplate>
                </Setter.Value>
            </Setter>
        </Style.Setters>
    </Style>

关闭按钮样式主要为了实现如下效果

（鼠标滑上，关闭按钮背景变灰色）

按钮的单击事件如下

private void CloseBTN_Click(object sender, RoutedEventArgs e)
        {
            var tc = this.Parent as TabControl;
            tc.Items.Remove(this);
        }

本文链接

SilverLight企业应用框架设计【一】整体说明

2012-01-03T08:24:00Z

闲言碎语~不要讲

先上图片

这个系列讲到的这个系统与

WinForm企业应用框架设计【一】界限划分与动态创建WCF服务（no svc!no serviceActivations!）

WinForm企业应用框架设计【二】团队内部的约定和客户端按约定识别WCF服务

WinForm企业应用框架设计【三】框架窗体设计；动态创建菜单；

WinForm企业应用框架设计【四】动态创建业务窗体

WinForm企业应用框架设计【五】系统登录以及身份验证+源码

这个系列类似

只不过是用在silverlight上的

当然，换了平台就换了很多技术

下面我说一下这个框架的一些特点

一：自己实现基于HTTP的REST服务

用siliverlight开发企业应用

大多人数都喜欢用微软提供的EntityFramework + RIA Service

由于某些特殊的原因需要

项目可能不能用EF和RIAService

那么这个系列将为您提供一些指导和最佳实践原则

二：自己实现客户端实体和服务代理的代码生成逻辑

使用RiaService的人肯定会知道

VS开发环境在Silverlight客户端

自动生成了服务代理的代码和实体的代码

这些代码放在

Generated_Code\[YorRIAService].g.cs

这个隐藏文件里

如果我们抛弃RIAService，

那么势必将自己完成这些代码生成工作

在我们这个系列中将介绍到

每次编译程序都会自动生成这些代码

的技巧

三：自己实现的DataForm控件

Silverlight提供的DataForm控件用以编辑实体

非常强大

但是太过强大了，把一些操作搞他复杂了

咱们这个系列将使用自己的DataForm控件

完成实体编辑业务逻辑

-------------------------------------

还有其他的一些诸如

自定义tabcontrol模版的技巧

都会在这个系列中讲到

------------------------------------

本系列是使用SL4开发的

如果您感兴趣

那么就请推荐吧！

系列的最后

我会放出源码的！

谢谢大家了！

本文链接

DotNet4应用程序打包工具->升级版【三】宿主程序分析+全部源码下载

2011-12-22T14:02:00Z

索引

DotNet4应用程序打包工具->升级版【三】宿主程序分析+全部源码下载

DotNet4应用程序打包工具->升级版【二】安装工具分析

DotNet4应用程序打包工具（把DotNet4安装程序打包进你的应用程序；WINAPI开发，无dotNet环境也可顺利执行）【一】整体思路

废话少说

入口函数

入口函数是所有逻辑的集合体

int WinMain(HINSTANCE hInstance,HINSTANCE hPreInstance,LPSTR lpCmdLine,int nCmdShow)
{
	int result;
	LPCTSTR netName = ".net4.exe";
	LPCTSTR tarName = ".tar.exe";
	result = CheckDotNet4();
	if(result == 0)
	{		
		result = FreeRC(MAKEINTRESOURCE(1012),netName);
		if(result == 0)
		{
			Alert("没有成功释放预装工具~安装失败");
			return 0;
		}
		result = CreateInstallProcess(netName);
		if(result == 0)
		{
			Alert("没有成功启动预装工具进程~安装失败");
			ClearFile(netName);
			return 0;
		}
		//暂时不支持静默安装
		//result = InstallIt();
		result = CheckDotNet4();
		if(result == 0)
		{
			Alert("没有成功安装预装工具~安装失败");
			ClearFile(netName);
			return 0;
		}
	}
	result = FreeRC(MAKEINTRESOURCE(1001),tarName);
	if(result == 0)
	{
		Alert("没有成功释放应用程序~安装失败");
		ClearFile(netName);
		ClearFile(tarName);
		return 0;
	}
	result = CreateInstallProcess(tarName);
	if(result == 0)
	{
		Alert("没有成功启动应用程序进程~安装失败");
	}
	ClearFile(netName);
	ClearFile(tarName);
	return 0;
}

判断目标环境是否有相关的注册表项

先从资源里提取出注册表项

然后判断

int CheckDotNet4()
{
	HMODULE hInstance = ::GetModuleHandle(NULL);
    HRSRC hResID = ::FindResource(hInstance,MAKEINTRESOURCE(1039),RT_RCDATA); 
    HGLOBAL hRes = ::LoadResource(hInstance,hResID);
    LPVOID pRes = ::LockResource(hRes);
	DWORD dwResSize = ::SizeofResource(hInstance,hResID);
	int length = MAX_PATH + 1;
	if(!dwResSize) 
	{
		return 0;
	}
	length = (int)dwResSize;
	TCHAR  regeditStr[MAX_PATH + 1];
	memcpy(regeditStr,pRes,dwResSize);
	regeditStr[dwResSize] = 0;
	HKEY ck;
	int result = 1;
	if(ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE,regeditStr,0,KEY_ALL_ACCESS,&ck))
	{       
		Alert("您的系统中缺少应用程序执行的环境\n现在开始为您搭建该环境");
		result = 0;
	}
	RegCloseKey(ck);
	return result;
}

如果没有相关的注册表项

就要释放出想要预先安装的程序

读取资源

并把资源写入文件

int FreeRC(LPCTSTR resourceID,LPCTSTR resourceName)
{    
    HMODULE hInstance = ::GetModuleHandle(NULL);
	TCHAR  szFilePath[MAX_PATH + 1];
	GetPath(szFilePath,resourceName,hInstance);
    HRSRC hResID = ::FindResource(hInstance,resourceID,RT_RCDATA); 
    HGLOBAL hRes = ::LoadResource(hInstance,hResID);
    LPVOID pRes = ::LockResource(hRes);
    DWORD dwResSize = ::SizeofResource(hInstance,hResID);
	if(!dwResSize)
	{
		return 0;
	}
    HANDLE hResFile = CreateFile(szFilePath,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);    
    DWORD dwWritten = 0;
    WriteFile(hResFile,pRes,dwResSize,&dwWritten,NULL);
    CloseHandle(hResFile);
    if(dwResSize == dwWritten);
	{
		return 1;
	}
	return 0;
}

成功释放之后

就执行这个程序

注意WaitForSingleObject的WINAPI

是等待进程退出

//创建进程
int CreateInstallProcess(LPCTSTR resourceName)
{
	STARTUPINFO stinfo;
	ZeroMemory((void*)&stinfo,sizeof(STARTUPINFO));
	PROCESS_INFORMATION ProcessInfo;
	stinfo.cb = sizeof(STARTUPINFO);
	stinfo.dwFlags = STARTF_USESHOWWINDOW;
	stinfo.wShowWindow = SW_SHOW;//SW_SHOW  SW_HIDE
	TCHAR  szFilePath[MAX_PATH + 1];
	GetPath(szFilePath,resourceName);//.dotnet4.exe
	int result = CreateProcess(szFilePath,NULL,NULL,NULL,false,0,NULL,NULL,&stinfo,&ProcessInfo);
	WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
	return result;        
}

如果进程没有被成功启动

就会删除释放的预安装程序

int ClearFile(LPCTSTR resourceName)
{
	TCHAR  szFilePath[MAX_PATH + 1];
	GetPath(szFilePath,resourceName);//.dotnet4.exe
	int result = ::DeleteFile(szFilePath);
	return result;
}

接着再次检查注册表项

result = CheckDotNet4();

如果仍旧没有相关的注册表项

那么说明预安装程序没有安装成功，退出程序

---------------------

至此，检查工作已经完成

入口函数里剩下的代码

是执行目标程序的工作

不在多做解释

result = FreeRC(MAKEINTRESOURCE(1001),tarName);
	if(result == 0)
	{
		Alert("没有成功释放应用程序~安装失败");
		ClearFile(netName);
		ClearFile(tarName);
		return 0;
	}
	result = CreateInstallProcess(tarName);
	if(result == 0)
	{
		Alert("没有成功启动应用程序进程~安装失败");
	}
	ClearFile(netName);
	ClearFile(tarName);

---------------------------

打包工具源码下载：BagDotNet_code.zip

宿主程序源码下载：CheckDotNet_code.zip

--------------------------------------------------------

如果您喜欢我的文章，请您推荐我的文章吧~谢谢~

本文链接

DotNet4应用程序打包工具->升级版【二】安装工具分析

2011-12-18T23:23:00Z

在本系列的上一篇中，

我们给出了这个工具的具体的思路。

得到了很多朋友的反馈！

综合朋友的意见，

在没有改变工具原理的基础上

我对这个程序做了升级

如下图：

如你所见，

现在这个打包工具可以打包dotNet2.0 3.5 4

乃至所有在注册表中添加过注册表项的应用程序

下面我们就开始分析安装工具（也就是上面你看到的那个图片）

--------------------------

入口函数：

int WinMain(HINSTANCE hInstance,HINSTANCE hPreInstance,LPSTR lpCmdLine,int nCmdShow)
{	
	DialogBox(hInstance,MAKEINTRESOURCE(MainWinDL),0,DlgProc);
	return 0;
}

好吧，入口函数很简单，只是创建了一个窗体，并注册了窗口过程函数

-----------------------------

窗口过程

//窗口过程
BOOL CALLBACK DlgProc (HWND hDlg, UINT message,WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
		case WM_INITDIALOG :
			OnInitDlg(hDlg);
			return TRUE ;
		case WM_COMMAND :
			switch (LOWORD(wParam))
			{
				case IDC_STATIC_Name:
					ShellExecute(hDlg,"open","http://www.cnblogs.com/liulun",NULL,NULL,SW_SHOWNORMAL); 
					break;
				case IDC_BUTTON1:	
					GetFile(hDlg,IDC_EDIT1);
					break;
				case IDC_BUTTON3:
					GetFile(hDlg,IDC_EDIT3);
					break;
				case IDC_RADIO1:
					CheckRadio(hDlg,IDC_RADIO1,"SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v2.0.50727");
					break;
				case IDC_RADIO2:
					CheckRadio(hDlg,IDC_RADIO2,"SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v3.5");
					break;
				case IDC_RADIO3:
					CheckRadio(hDlg,IDC_RADIO3,"SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v4");
					break;
				case IDC_RADIO_ELSE:
					CheckRadio(hDlg,IDC_RADIO_ELSE,"");
					break;
				case IDOK:
					ReleaseTar(hDlg);
					ReplaceICO(hDlg);
					BagTar(hDlg,IDC_EDIT3);
					BagTar(hDlg,IDC_EDIT1);
					BagStr(hDlg);
					Alert("打包成功");
					break;
				case IDCANCEL:
					EndDialog (hDlg, 0) ;
					return TRUE ;
			}
		break;
    }
    return FALSE ;
}

在这个过程函数里

接收到的每个消息都执行了一个或几个函数

那么，我们就一个函数一个函数的讲

-------------------------------------------------------

窗口初始化消息里

我们默认选中了dotNet4的单选按钮

void OnInitDlg(HWND hwnd)
{
	HWND cld = ::GetDlgItem(hwnd,IDC_RADIO3);
	::SendMessage(cld,BM_SETCHECK,1,0);
	::SetDlgItemText(hwnd,IDC_EDIT2,"SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v4");
	LastCheckRdioId = IDC_RADIO3;
}

---------------------------------------------------------

四个单选按钮的单击事件

设置了文本框的内容，

并记录了当前选中的是哪个单选按钮

void CheckRadio(HWND hwnd,int rdioID,LPCSTR val)
{
	if(rdioID == LastCheckRdioId)
	{
		return;
	}
	::SetDlgItemText(hwnd,IDC_EDIT2,val);
	LastCheckRdioId = rdioID;
}

------------------------------------------------------------

选择文件

把选中的文件路径赋值给相应的文本框

//得到文件
void GetFile(HWND hwnd,int EDITId)
{
	char szFile[MAX_PATH] = {0};
	OPENFILENAME ofn;
	memset(&ofn, 0, sizeof(OPENFILENAME));   
	ofn.lStructSize = sizeof(OPENFILENAME);     
	ofn.lpstrFile = szFile;   
	ofn.nMaxFile = MAX_PATH;   
	ofn.lpstrFilter = "应用程序 (.exe)\0*.exe\0\0";
	ofn.lpstrDefExt = "exe";   
	ofn.lpstrTitle = "选择exe文件";
	ofn.nFilterIndex = 1;   
	ofn.lpstrFileTitle = NULL;   
	ofn.nMaxFileTitle = 0;   
	ofn.lpstrInitialDir = NULL;
	if(GetOpenFileName(&ofn))
	{
		SetDlgItemText(hwnd,EDITId,szFile);
	}
}

--------------------------------------------------------------------

从资源中读取宿主程序，并按指定的文件名，释放到当前目录下

//释放资源
int ReleaseTar(HWND hwnd)
{	
	::GetDlgItemText(hwnd,IDC_EDIT1,szFilePath,MAX_PATH);
	::strcat(szFilePath,".bag.exe");

	HMODULE hInstance = ::GetModuleHandle(NULL);
    HRSRC hResID = ::FindResource(hInstance,(LPCSTR)IDR_BIN1,"bin"); 
    HGLOBAL hRes = ::LoadResource(hInstance,hResID);
    LPVOID pRes = ::LockResource(hRes);
    DWORD dwResSize = ::SizeofResource(hInstance,hResID);
	if(!dwResSize)
	{
		return 0;
	}
    HANDLE hResFile = CreateFile(szFilePath,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);    
    DWORD dwWritten = 0;
    WriteFile(hResFile,pRes,dwResSize,&dwWritten,NULL);
    CloseHandle(hResFile);
    if(dwResSize == dwWritten);
	{
		return 1;
	}
	return 0;
}

---------------------------------------------------------------------------

替换宿主程序的ICO图标资源

这里需要重点说明一下：

要想更新一个应用程序的资源

必须先知道这个资源的ID

GetIcoIndex函数的工作就是获取资源ID的

因为一般的应用程序图标资源都会有两个

所以获取了两个图表资源的ID

其他的WINAPI就不多解释了~~

int GetIcoIndex(HMODULE hExe,int index[])
{
	HRSRC hRes;
	int iLoop;
	int i = 0;
	for(iLoop = 1;;iLoop++)
    {
        hRes = FindResource(hExe, MAKEINTRESOURCE(iLoop), RT_ICON); 
		if (NULL == hRes)
		{
			if(iLoop == 60)
			{
				break;
			}
			continue ; 
		}
        else
		{
			index[i]  = iLoop;
			i +=1;
			if(i == 2)
			{
				break;
			}
		}
    }
	return 1;
}
int ReplaceICO(HWND hwnd)
{
	HMODULE hSrcExe,hDestExe;
	HANDLE hUpdateRes;
	HRSRC hRes;
	HRSRC hResLoad;
	char *lpResLock;
	int result;
	char szFile[MAX_PATH+1] = {0};
	int hSrcIndex[2] = {0};
	int hDestIndex[2] = {0};
	::GetDlgItemText(hwnd,IDC_EDIT1,szFile,MAX_PATH);
	hSrcExe = LoadLibrary(szFile);
	hDestExe = LoadLibrary(szFilePath);
	GetIcoIndex(hSrcExe,hSrcIndex);
	GetIcoIndex(hDestExe,hDestIndex);
	for(int i=0;i<2;i++)
	{
		hRes = FindResource(hSrcExe, MAKEINTRESOURCE(hSrcIndex[i]), RT_ICON); 
		hResLoad=(HRSRC)LoadResource(hSrcExe,hRes);
		lpResLock=(char*)LockResource(hResLoad);
		FreeLibrary(hDestExe);
		hUpdateRes=BeginUpdateResource(szFilePath,FALSE);
		result=UpdateResource(hUpdateRes,RT_ICON,MAKEINTRESOURCE(hDestIndex[i]),MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),lpResLock,SizeofResource(hSrcExe,hRes));
		EndUpdateResource(hUpdateRes, FALSE);
	}
	FreeLibrary(hSrcExe);
	return result;
}

---------------------------------------

为宿主程序增加目标程序资源和dotNet安装包资源

增加的资源也是需要标明ID的

因为宿主程序会根据约定好的ID来得到这些资源

EditId参数就是这些资源的ID

int BagTar(HWND hwnd,int EditId)
{
	HANDLE hFile;
	DWORD dwFileSize,dwBytesRead;
	LPBYTE lpBuffer;
	char szFile[MAX_PATH+1] = {0};
	::GetDlgItemText(hwnd,EditId,szFile,MAX_PATH);
	hFile = CreateFile(szFile,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
	dwFileSize = GetFileSize(hFile, NULL);
	lpBuffer = new BYTE[dwFileSize];
	ReadFile(hFile, lpBuffer, dwFileSize, &dwBytesRead, NULL);
	HANDLE hResource = BeginUpdateResource(szFilePath, FALSE);
	UpdateResource(hResource,RT_RCDATA,MAKEINTRESOURCE(EditId),MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),(LPVOID)lpBuffer,dwFileSize);	
	EndUpdateResource(hResource, FALSE);	
	delete [] lpBuffer; 
	CloseHandle(hFile);
	return 1;
}

--------------------------------------------------------

把注册表项的路径也当作资源打包进宿主程序

我们约定这个资源的ID为1039

int BagStr(HWND hwnd)
{
	char szFile[MAX_PATH+1] = {0};
	::GetDlgItemText(hwnd,IDC_EDIT2,szFile,MAX_PATH);
	HANDLE hUpdateRes=BeginUpdateResource(szFilePath,FALSE);
	int result=UpdateResource(hUpdateRes,RT_RCDATA,MAKEINTRESOURCE(1039),MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),(LPVOID)szFile,::strlen(szFile));
	EndUpdateResource(hUpdateRes, FALSE);
	return 0;
}

-------------------------------------------------------------

其他的一些代码如下

#include <Windows.h>
#include <ShlObj.h>
#include "resource.h"

TCHAR szFilePath[MAX_PATH + 1];

int LastCheckRdioId;
//提示
void Alert(LPCSTR msg)
{
	MessageBox(NULL,msg,"系统提示",MB_OK);	
}

---------------------------------------------------------------

后记：

没有写容错的代码~

也没有遵循命名规范~

大家见谅~

请各位推荐我的文章

因为你们的支持才是我的动力->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->

此工具编译后的可执行文件下载地址：BagDotNet.zip

（因为不在需要把dotNet4安装程序打包进来，所以只有几十K了！多轻便啊！）

本文链接