WPF入门系列二——Application介绍

三种方式启动应用程序

都是在App.cs文件中编写以下代码。

第一种

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
namespace WpfApp1
{
    class App
    {
        [STAThread]
        static void Main()
        {
            // 定义Application对象作为整个应用程序入口  
            Application app = new Application();
            // 方法一：调用Run方法 ,这种方式跟winform的调用一样
            WindowGrid win = new WindowGrid();
            app.Run(win);
        }
    }
}

第二种

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
namespace WpfApp1
{
    class App
    {
        [STAThread]
        static void Main()
        {
            // 定义Application对象作为整个应用程序入口  
            Application app = new Application();
             //指定Application对象的MainWindow属性为启动窗体，然后调用无参数的Run方法  
            WindowGrid win = new WindowGrid();  
            app.MainWindow = win;
            //是必须的，否则无法显示窗体       
            win.Show();
            app.Run();  
        }
    }
}

第三种

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
namespace WpfApp1
{
    class App
    {
        [STAThread]
        static void Main()
        {
            // 定义Application对象作为整个应用程序入口  
            Application app = new Application();
            // 通过Url的方式启动
            app.StartupUri = new Uri("WindowGrid.xaml", UriKind.Relative);
            app.Run();
        }
    }
}

WPF入门系列三——Application介绍（续）

一、WPF应用程序的关闭

WPF应用程序的关闭只有在应用程序的 Shutdown 方法被调用时，应用程序才停止运行。 ShutDown 是隐式或显式发生，可以通过指定 ShutdownMode 的属性值来进行设置。

1、对ShutdownMode选项的更改，可以直接在App.xaml中更改，如下代码：

<Application x:Class="WpfApp1.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"            
             StartupUri="MainWindow.xaml" ShutdownMode="OnExplicitShutdown" >
    <Application.Resources>
    </Application.Resources>
</Application>

2、在代码文件（App.xaml.cs）中修改ShutdownMode选项，但必须注意这个设置要写在app.Run()方法之前，如下代码：

[STAThread]
static void Main()
{
    ......
    app.ShutdownMode = ShutdownMode.OnExplicitShutdown;
    app.Run(win);
}

Application对象的其他属性：

二、添加Application对象事件

在应用程序中添加事件的方式有如下三种。

第一种方式：

1、在App.xaml中做事件的绑定，在App.xaml.cs文件中添加事件的处理方法。

在App.xaml文件中，具体添加方法见下图：

2、添加完事件后的App.xaml文件代码如下：

<Application x:Class="WpfApp1.App"    
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"   
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"   
             StartupUri="MainWindow.xaml" ShutdownMode="OnExplicitShutdown" Activated="Application_Activated" Exit="Application_Exit">
  <Application.Resources>
  </Application.Resources> 
</Application>

3、在App.xaml.cs文件的代码如下：

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
namespace WpfApp1
{
    /// <summary>
    /// App.xaml 的交互逻辑
    /// </summary>
    public partial class App : Application
    {
        private void Application_Activated(object sender, EventArgs e)
        {
        }
        private void Application_Exit(object sender, ExitEventArgs e)
        {
        }
    }
}

4、在使用以上方式添加事件之后，如果在 Visual Studio 中按 F5 执行应用程序时，报以下错误“不包含适合于入口点的静态‘Main’方法”。这个错误是由于 Visual Studio 把项目文件（*.csproj）中原来自动生成的 app.xaml 相关的定义进行了修改。具体区别如下：

1）直接新建在WPF项目中的有关 App.xaml 的定义如下：

<ApplicationDefinition Include="App.xaml">
  <Generator>MSBuild:Compile</Generator>
  <SubType>Designer</SubType>
</ApplicationDefinition>

2）Visual Studio 把修改后的 App.xaml 的配置代码如下：

<Page Include="App.xaml">
  <SubType>Designer</SubType>
  <Generator>MSBuild:Compile</Generator>
</Page>

第一段代码中 App.xaml 在项目文件里面用 ApplicationDefinition 标签定义。第二段代码中 App.xaml 在项目文件中用 Page 标签定义，这种定义是指 App.xaml只是一个页面而已。

因此，只需要把项目文件中将 App.xaml 的配置由 Page 修改成 ApplicationDefinition即可。

第二种方式

1、可以像是在WinForm中的Program类中写Main方法一样，在WPF中一样可以自定义一个app类中写main及其他相关事件。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
namespace WpfApp1
{
    class App
    {
        [STAThread]
        static void Main()
        {
            // 定义Application对象作为整个应用程序入口 
            Application app = new Application();
            MainWindow win = new MainWindow();
            app.ShutdownMode = ShutdownMode.OnMainWindowClose;
            app.MainWindow = win;
            //是必须的，否则无法显示窗体      
            win.Show();
            app.Run();
            app.Activated += app_Activated;
            app.Exit += app_Exit;
        }
        static void app_Activated(object sender, EventArgs e)
        {
             throw new NotImplementedException();
        }
         static void app_Exit(object sender, ExitEventArgs e)
         {
             throw new NotImplementedException();
         }
    }
}

第三种方式

1、在App.xaml界面中，如下图位置1处，输入Exit事件名称，VS会弹出一个菜单“新建事件处理程序”，双击这个菜单，VS会自动创建一个“Application_Exit”事件，如下图位置2处：

三、WPF应用程序生命周期

WPF应用程序的生命周期与执行顺序，用MSDN上的一张图片进行说明。下图显示了窗口的生存期中的主要事件的顺序：

WPF入门系列四——Dispatcher介绍

一、Dispatcher介绍

不管是WinForm应用程序还是WPF应用程序，实际上都是一个进程，一个进程可以包含多个线程，其中有一个是主线程。在WPF或WinForm应用程序中，主线程负责接收输入、处理事件、绘制屏幕等工作，为了使主线程及时响应，防止假死，在开发过程中对一些耗时的操作、消耗资源比较多的操作，都会去创建一个或多个子线程去完成操作，比如大数据量的循环操作、后台下载。这样一来，由于UI界面是主线程创建的，所以子线程不能直接更新由主线程维护的UI界面。

Dispatcher 的作用是用于管理线程工作项队列，类似于Win32中的消息队列，Dispatcher的内部函数，仍然调用了传统的创建窗口类，创建窗口，建立消息泵等操作。Dispatcher本身是一个单例模式，构造函数私有,暴露了一个静态的CurrentDispatcher方法用于获得当前线程的Dispatcher。对于线程来说，它对Dispatcher是一无所知的，Dispatcher内部维护了一个静态的List_dispatchers，每当使用CurrentDispatcher方法时，它会在这个_dispatchers中遍历，如果没有找到，则创建一个新的Dispatcher对象，加入到_dispatchers中去。Dispatcher内部维护了一个Thread的属性，创建Dispatcher时会把当前线程赋值给这个Thread的属性，下次遍历查找的时候就使用这个字段来匹配是否在_dispatchers中已经保存了当前线程的Dispatcher。

二、Dispatcher的继承关系

在WPF的类层次结构中，大部分都集中派生于DispatcherObject类（通过其他类）。如下图所示，DispatcherObject虚拟类正好位于Object下方和大多数WPF类的层次结构之间。要了解它们之间的关系可以参看下面这张类的继承关系图。

WPF中的绝大部分的控件，还包括窗口本身都是继承自ContentControl的。

ContentControl族包含的控件：

9）System.Windows.Controls.ItemsControl 类：表示可用于提供项目的集合的控件。

以条目集合内容的控件 ItemControl

特点：①均派生自ItemControl

②内容属性为Items或ItemsSource
③每种ItemsControl都对应有自己的条目容器（Item Container）。

ItemsControl族包含的控件：

三、走进Dispatcher

所有的WPF应用程序启动时都会加载两个重要的线程：一个用于呈现用户界面，另一个用于管理用户界面。呈现线程是一个在后台运行的隐藏线程，因此你通常面对的唯一线程就是UI线程。WPF要求将其大多数对象与UI线程相关联。这称之为线程关联，意味着要使用一个WPF对象，只能在创建它的线程上使用。在其他线程上使用它会导致运发运行时异常。UI线程的作用时用于接收输入、处理事件、绘制屏幕以及运行应用程序代码。

在WPF中绝大部分控件都继承自 DispatcherObject，甚至包括Application。这些继承自 DispatcherObject的对象具有线程关联特征，也就意味着只有创建这些对象实例，且包含了Dispatcher的线程（通常默认UI线程）才能直接对其进行更新操作。

DispatcherObject类有两个主要职责：提供对对象所关联的当前 Dispatcher的访问权限，以及提供方法以检查（CheckAccess）和验证（VerifyAccess）某个线程是否有权访问对象（派生于DispatcherObject）。CheckAccess与VerifyAccess的区别在于 CheckAccess返回一个布尔值，表示当前线程是否可以使用对象，而VerifyAccess则在线程无权访问对象的情况下引发异常。通过提供这些基本的功能，所有WPF对象都支持对是否可在特定线程（特别是UI线程）上使用它们加以确定。

在WPF中，DispatcherObject只能通过与它关联的 Dispatcher进行访问。例如，后台线程不能更新由UI线程创建的 Label的内容。

那么如何更新UI线程创建的对象信息呢？Dispatcher提供了两个方法，Invoke和BeginInvoke，这两个方法还有多个不同参数的重载。其中Invoke内部还是调用了BeginInvoke，一个典型的BeginInvoke参数如下：

public DispatcherOperation BeginInvoke(Delegate method, DispatcherPriority priority, params object[] args);

Invoke时同步操作，而BeginInvoke是异步操作。这两个操作将指定的Dispatcher添加到Dispatcher的队列中。DispatcherPriority定义了很多优先级，可以分为前台优先级和后台优先级，其中前台包括Loaded~Send，后台包括Background~Input。剩下的几个优先级除了Invalid和Inactive都属于空闲优先级。这个前台优先级和后台优先级的分界线是以Input来区分的，这里的Input指的是键盘输入和鼠标移动、点击等等。

DispatcherPrioirty优先级：

四、使用Dispatcher

下面来看看如何正确从一个非UI线程中更新一个由UI线程创建的对象。

<Window x:Class="DispatcherTestDemo.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:DispatcherTestDemo"
        mc:Ignorable="d"
        Title="MainWindow" Height="300" Width="400">
  <Grid>
    <StackPanel>
      <Label x:Name="lblHello">欢迎你光临WPF的世界</Label>
      <Button Name="btnThd" Click="btnThd_Click">多线程同步调用</Button>
      <Button Name="btnAppBeginInvoke" Click="btnAppBeginInvoke_Click">BeginInvoke 异步调用</Button>
    </StackPanel>
  </Grid>
</Window>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
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;
using System.Windows.Threading;
namespace DispatcherTestDemo
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
        public void ModifyUI()
        {
            //模拟一些工作正在运行
            Thread.Sleep(TimeSpan.FromSeconds(2));
            //如果按下面这行代码来写,是从子线程中直接更新UI线程创建的对象,会报错。
            //lblHello.Content = "欢迎你光临WPF的世界，Dispatcher";
            //改为使用Dispatcher的Invoke方法,Invoke方法是同步方法。
            this.Dispatcher.Invoke(DispatcherPriority.Normal, (ThreadStart)delegate ()
             {
                 lblHello.Content = "欢迎你光临WPF的世界，Dispatcher 同步方法！";
             });
        }
        //点击按钮完成对Label的Content的更新
        private void btnThd_Click(object sender, RoutedEventArgs e)
        {
            Thread thread = new Thread(ModifyUI);
            thread.Start();
        }
        //这个按钮就用Dispatcher的BeginInvoke异步方法实现。
        private void btnAppBeginInvoke_Click(object sender, RoutedEventArgs e)
        {
            new Thread(() =>
            {
                Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal,
                    new Action(() =>
                    {
                        Thread.Sleep(TimeSpan.FromSeconds(2));
                        this.lblHello.Content = "欢迎你光临WPF的世界，Dispatcher 异步方法！";
                    }));
            }).Start();
        }
    }
}

执行效果：

五、小结

在WPF中，所有的WPF对象都派生自DispatcherObject，DispatcherObject暴露了Dispatcher属性用来取得创建对象线程对应的Dispatcher。DispatcherObject对象只能被创建它的线程所访问，其他线程修改DispatcherObject需要取得对应的Dispatcher，调用Invoke或者BeginInvoke来投入任务。Dispatcher的一些设计思路包括Invoke和BeginInvoke等从WinForm时代就是一直存在的，只是使用了Dispatcher来封装这些线程级的操作。

WPF入门系列五——Window介绍

一、窗体类基本概念

对于WPF应用程序，在Visual Studio和Expression Blend中，自定义的窗体均继承System.Windows.Window类。用户通过与WPF独立应用程序进行交互。窗口的主要用途是承载可视化数据并使用户可以与数据进行交互的内容。独立WPF应用程序使用Window类来提供它们自己的窗口。在WPF中，可以使用代码或XAML标记来实现窗口的外观和行为。我们这里定义的窗体也由这两部分组成：

1、XAML文件，在这里面通常全部写UI的东西，包括窗口的外观、控件等。

2、窗口界面中的各种行为，则由后台代码文件决定。

二、窗体的生命周期

和所有类一样，窗口也有生存期，在第一次实例化窗口时生存期开始，然后就可以显示、激活和停用窗口，直到最终关闭窗口。

1、显示窗体

    * 构造函数
    * Show()、ShowDialog()方法：Show()方法显示非模态窗口，这意味着应用程序所运行的模式允许用户在同一个应用程序中激活其他窗口。ShowDislog()方法显示模态窗口，这个基本和WinForm类似
    * 当初始化窗口时，将引发SourceInitialized事件并显示窗口。

2、窗体的激活

在首次打开一个窗口时，它便成为活动窗口（除非是在ShowActivited设置为false的情况下显示）。活动窗口是当前正在捕获用户输入（例如，键击和鼠标单击）的窗口。当窗口变为活动窗口时，它会引发Activated事件。

当第一次打开窗口时，只有在引发了Activited事件之后，才会引发Loaded和ContentRendered事件。记住这一点，在引发ContentRendered时，便可认为窗口已打开。

窗口变为活动窗口后，用户可以在同一个应用程序中激活其他窗口，还可以激活其他应用程序。当这种情况出现时，当前的活动窗口将停用，并引发Deactivated事件。同样，当用户选择当前停用的窗口时，该窗口会再次变成活动窗口并引发Activated。

3、关闭窗体

当用户关闭窗口时，窗口的生命便开始走向终结。

    * Close()方法：关闭窗体，并释放窗体的资源
    * Closing事件、Closed事件：关闭时、关闭后引发的事件，通常在Closing事件中提示用户是否退出等信息。

4、窗体的生命周期，如下图：

下面通过代码验证：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
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.Shapes;
using System.Windows.Threading;
namespace WpfApp1
{
    /// <summary>
    /// WindowThd.xaml 的交互逻辑
    /// </summary>
    public partial class WindowThd : Window
    {
        public WindowThd()
        {
            this.Activated += WindowThd_Activated;
            this.Closing += WindowThd_Closing;
            this.ContentRendered += WindowThd_ContentRendered;
            this.Deactivated += WindowThd_Deactivated;
            this.Loaded += WindowThd_Loaded;
            this.Closed += WindowThd_Closed;
            this.Unloaded += WindowThd_Unloaded;
            this.SourceInitialized += WindowThd_SourceInitialized;
            InitializeComponent();
        }
        void WindowThd_SourceInitialized(object sender, EventArgs e)
        {
            Console.WriteLine( "1---SourceInitialized！");
        }
        void WindowThd_Unloaded(object sender, RoutedEventArgs e)
        {
            Console.WriteLine("Unloaded！");
        }
        void WindowThd_Closed(object sender, EventArgs e)
        {
            Console.WriteLine("_Closed！");
        }
        void WindowThd_Loaded(object sender, RoutedEventArgs e)
        {
             Console.WriteLine( "3---Loaded！");
        }
        void WindowThd_Deactivated(object sender, EventArgs e)
        {
            Console.WriteLine("Deactivated！");
        }
        void WindowThd_ContentRendered(object sender, EventArgs e)
        {
            Console.WriteLine("ContentRendered！");
        }
        void WindowThd_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            Console.WriteLine("---Closing！");
        }
        void WindowThd_Activated(object sender, EventArgs e)
        {
            Console.WriteLine("2---Activated！");
        }
        private void ModifyUI()
        {
            // 模拟一些工作正在进行
            Thread.Sleep(TimeSpan.FromSeconds(2));
            //lblHello.Content = "欢迎你光临WPF的世界,Dispatcher";
            this.Dispatcher.Invoke(DispatcherPriority.Normal, (ThreadStart)delegate()
            {
                lblHello.Content = "欢迎你光临WPF的世界,Dispatche  同步方法 ！！";
            });
        }
        private void btnThd_Click(object sender, RoutedEventArgs e)
        {
            Thread thread = new Thread(ModifyUI);
            thread.Start();
        }
        private void btnAppBeginInvoke_Click(object sender, RoutedEventArgs e)
        {
            new Thread(() =>
            {
                 Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal,
                     new Action(() =>
                     {
                        Thread.Sleep(TimeSpan.FromSeconds(2));
                        this.lblHello.Content = "欢迎你光临WPF的世界,Dispatche 异步方法！！"+ DateTime.Now.ToString();
                     }));
            }).Start();
        }
    }
}

打开窗体的事件执行顺序如下：

关闭窗体的事件顺序如下：

WPF入门系列——布局介绍与Canvas

从这篇文章开始是对WPF中的界面如何布局做一个简单的介绍。

一、总体介绍

WPF的布局控件都在System.Windows.Controls.Panel这个基类下面，使用WPF提供的各种控件在WPF应用程序中界面进行布局，同时对各种子控件（如按钮、文本框、下拉框等）进行排列组合。

Panel类的公共属性太多了，就简单介绍几个常见的属性如下表：

二、Canvas

Canvas是最基本的面板，只是一个存储控件的容器，它不会自动调整内部元素的排列及大小，它仅支持用显式坐标定位控件，它也允许指定相对任何角的坐标，而不仅仅是左上角。可以使用Left、Top、Right、Bottom附加属性在Canvas中定位控件。通过设置Left和Right属性的值表示元素最靠近的那条边，应该与Canvas左边缘或右边缘保持一个固定的距离，设置Top和Bottom的值也是类似的意思。实质上，你在选择每个控件停靠的角时，附加属性的值是作为外边距使用的。如果一个控件没有使用任何附加属性，它会被放在Canvas的左上方（等同于设置Left和Top为0）。

Cancas的主要用途是用来画图。Canvas默认不会自动裁剪超过自身范围的内容，即溢出的内容会显示在Canvas外面，这是因为默认ClipToBounds=”False”；我们可以通过设置ClipToBounds=”True”来裁剪多出的内容。

接下来看两个实例，第一个实例用XAML代码实现：

<Window x:Class="WpfApp1.WindowCanvas"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="WindowCanvas" Height="400" Width="500">
    <Grid>
        <Canvas Margin="0,0,0,0" Background="White">
            <Rectangle Fill="Blue" 
                Stroke="Azure" 
                Width="250" 
                Height="200" 
                Canvas.Left="210" Canvas.Top="101"/>
            <Ellipse Fill="Red" 
                Stroke="Green" 
                Width="250" Height="100" 
                Panel.ZIndex="1" 
                Canvas.Left="65" Canvas.Top="45"/>
        </Canvas>
        <Canvas>
            <Button Name="btnByCode" Click="btnByCode_Click">后台代码实现</Button>
        </Canvas>
    </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.Shapes;
namespace WpfApp1
{
    /// <summary>
    /// WindowCanvas.xaml 的交互逻辑
    /// </summary>
    public partial class WindowCanvas : Window
    {
        public WindowCanvas()
        {
            InitializeComponent();
        }
        public void DisplayCanvas()
        {
            Canvas canv = new Canvas();
            //把canv添加为窗体的子控件
            this.Content = canv;
            canv.Margin = new Thickness(0, 0, 0, 0);
            canv.Background = new SolidColorBrush(Colors.White);
            //Rectangle
            Rectangle r = new Rectangle();
            r.Fill = new SolidColorBrush(Colors.Red);
            r.Stroke = new SolidColorBrush(Colors.Red);
            r.Width = 200;
            r.Height = 140;
            r.SetValue(Canvas.LeftProperty, (double)200);
            r.SetValue(Canvas.TopProperty, (double)120);
            canv.Children.Add(r);
            //Ellipse
            Ellipse el = new Ellipse();
            el.Fill = new SolidColorBrush(Colors.Blue);
            el.Stroke = new SolidColorBrush(Colors.Blue);
            el.Width = 240;
            el.Height = 80;
            el.SetValue(Canvas.ZIndexProperty, 1);
            el.SetValue(Canvas.LeftProperty, (double)100);
            el.SetValue(Canvas.TopProperty, (double)80);
            canv.Children.Add(el);
        }
        private void btnByCode_Click(object sender, RoutedEventArgs e)
        {
            DisplayCanvas();
        }
    }
}

最后，说明一点**Canvas内的子控件不能使用两个以上的Canvas附加属性**，如果同时设置Canvas.Left和Canvas.Right属性，那么后者将会被忽略。

三、WrapPanel

WrapPanel布局面板将各个控件从左至右按照行或列的顺序罗列，当长度或高度不够时就会自动调整进行换行，后续排序按照从上至下或从右至左的顺序进行。

Orientation——根据内容自动换行。当Horizontal选项看上去类似于Windows资源管理器的缩略图视图：元素是从左向右排列的，然后从上至下自动换行。Vertical选项看上去类似于Windows资源管理器的列表视图：元素是从上向下排列的，然后从左至右自动换行。

ItemHeight——所有子元素都一致的高度。每个子元素填充高度的方式取决于它的VerticalAlignment属性、Height属性等。任何比ItemHeight高的元素都将被截断。

ItemWidth——所有子元素都一致的宽度。每个子元素填充宽度的方式取决于它的VerticalAlignment属性、Width属性等。任何比ItemWidth宽的元素都将被截断。

本次的示例，效果如下2图，图1是宽度比较小，图2就是拉长了宽度后的结果。

示例代码：

<Window x:Class="CanvasTestDemo.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:CanvasTestDemo"
        mc:Ignorable="d"
        Title="WindowWrap" Height="300" Width="400">
  <Grid>
    <WrapPanel Orientation="Horizontal">
      <TextBlock Name="textBlock_CityID" Text="CityID:" />
      <TextBox Name="textBox_CityID" MinWidth="100" />
      <TextBlock Name="textBlock_CityName" Text="CityName:" />
      <TextBox Name="textBox_CityName" MinWidth="100" />
      <TextBlock Name="textBlock_ZipCode" Text="ZipCode:" />
      <TextBox Name="textBox_ZipCode" MinWidth="100"  />
      <TextBlock Name="textBlock_ProvinceID" Text="ProvinceID:" />
      <TextBox Name="textBox_ProvinceID" MinWidth="100"   />
      <TextBlock Name="textBlock_DateCreated" Text="DateCreated:"  />
      <TextBox Name="textBox_DateCreated" MinWidth="100"   />
      <TextBlock Name="textBlock_DateUpdated" Text="DateUpdated:" />
      <TextBox Name="textBox_DateUpdated" MinWidth="100" />
    </WrapPanel>
  </Grid>
</Window>

使用C#代码实现下面示例：

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.Shapes;
namespace WpfApp1
{
    /// <summary>
    /// WindowWrap.xaml 的交互逻辑
    /// </summary>
    public partial class WindowWrap : Window
    {
        public WindowWrap()
        {
            InitializeComponent();
        }
        private void btnAddByCode_Click(object sender, RoutedEventArgs e)
        {
            WrapPanel wp = new WrapPanel();
            //把wp添加为窗体的子控件
            this.Content = wp;
            wp.Margin = new Thickness(0, 0, 0, 0);
            wp.Background = new SolidColorBrush(Colors.White);
            //遍历增加TextBlock
            TextBlock block;
            for (int i = 0; i <= 10; i++)
            {
                block = new TextBlock();
                block.Text = "后台代码添加控件：" + i.ToString();
                block.Margin = new Thickness(10, 10, 10, 10);
                block.Width = 160;
                block.Height = 30;
                wp.Children.Add(block);
            }       
        }
    }
}

四、StackPanel

StackPanel就是将控件按照行或列来顺序排列，但不会换行。通过设置面板的 Orientation 属性设置了两种排列方式：横排（Horizontal默认的）和竖排（Vertical）。纵向的 StackPanel 默认每个元素宽度与面板一样宽，反之横向亦然。如果包含的元素超过了面板空间，它只会截断多出的内容。元素的 Margin 属性用于使元素之间产生一定的间隔，当元素空间大于其内容的空间时，剩余空间将由 HorizontalAlignment 和 VerticalAlignment 属性来决定如何分配。

下面这个案例实现效果：点击按钮“第五个，改变排列方式”后（图1），窗口变成竖着排列所有按钮
（图2）；点击“后台代码实现”按钮，变成图3。

代码实现：

<Window x:Class="StackPanelTestDemo.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:StackPanelTestDemo"
        mc:Ignorable="d"
        Title="WindowStack" Height="400" Width="500">
    <Grid>
        <StackPanel Name="stackPanel" Margin="0,0,0,0" Background="White" Orientation="Vertical">
            <Button Content="第一个"/>
            <Button Content="第二个"/>
            <Button Content="第三个"/>
            <Button Content="第四个"/>
            <Button Content="第五个，改变排列方式" Click="Button_Click"/>
            <Button Content="后台代码实现" Click="Button_Click_1"/>
        </StackPanel>
    </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 StackPanelTestDemo
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            stackPanel.Orientation = Orientation.Horizontal;
        }
        private void StackPanels()
        {
            StackPanel sp = new StackPanel();
            //把sp添加为窗体的子控件
            this.Content = sp;
            sp.Margin = new Thickness(0, 0, 0, 0);
            sp.Background = new SolidColorBrush(Colors.White);
            sp.Orientation = Orientation.Vertical;
            //Button1
            Button b1 = new Button();
            b1.Content = "后台代码，第一个";
            sp.Children.Add(b1);
            //Button2
            Button b2 = new Button();
            b2.Content = "后台代码，第二个";
            sp.Children.Add(b2);
            //Button3
            Button b3 = new Button();
            b3.Content = "后台代码，第三个";
            sp.Children.Add(b3);
        }
        private void Button_Click_1(object sender, RoutedEventArgs e)
        {
            StackPanels();
        }
    }
}

注：当把StackPanel 的FlowDirection 属性设置为 RightToLeft，Orientation属性设置为 Horizontal，StackPanel 将从右向左排列元素。

五、Grid

Grid顾名思义就是“网格”，它的子控件被放在一个一个实现定义好的小格子里面，整齐排列。Grid和其他各个Panel比较起来，功能最多也最复杂。要使用Grid，首先要向RowDefinitions 和ColumnDefinitions属性中添加一定数量的RowDefinitions和ColumnDefinitions元素，从而定义行数和列数。而放置在Grid面板中的控件元素都必须显示采用附加属性语法定义其放置所在的行和列，它们都是以0为基准的整型值（下标都是从0开始的），如果没有显式设置任何行或列，Grid将会隐式地将控件放入第0行第0列。由于Grid的组成并非简单的添加属性标记来区分行列，这也使得用户在实际应用中可以具体到某一单元格中，所以布局起来就很精细了。

Grid的单元格可以是空的，一个单元格中可以有多个元素，而在单元格中元素是根据它们的顺序一个接着一个呈现的。与Canvas一样，同一个单元格中的子元素不会与其他元素交互布局，信息——它们仅仅是重叠而已。接下来我们来使用一些实际的代码演示一下如何使用Grid。

（1）Grid的列宽与行高可采用固定、自动、按比例三种方式定义：

第一种，固定长度——宽度不够，会裁剪，不好用。单位pixel。

第二种，自动长度——自动匹配列中最长元素的宽度。

第三种，比例长度——表示占用剩余的全部宽度；两行都是，将平分剩余宽度；像上面的一个2，一个，表示前者2/3宽度。

（2）跨越多行和多列

<Rectangle Fill="Silver" Grid.Column="1" Grid.ColumnSpan="3"/>

使用Grid.ColumnSpan和Grid.RowSpan附加属性可以让相互间隔的行列合并，所以元素也可以跨越多个单元格。

（3）使用GridSplit分割

<GridSplitter Height="6" VerticalAlignment="Stretch" HorizontalAlignment="Stretch" Grid.Row="2" Grid.Column="2"/>

使用GridSplit控件结合Grid控件实现类似于WinForm中 SplitContainer 的功能。

（4）XAML代码实现下图效果：

<Window x:Class="WpfApp1.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:WpfApp1"
        mc:Ignorable="d"
        Title="MainWindow" Height="300" Width="450">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="61*"/>
            <RowDefinition Height="101*"/>
            <RowDefinition Height="108*"/>
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="139"/>
            <ColumnDefinition Width="184*"/>
            <ColumnDefinition Width="45*"/>
            <ColumnDefinition Width="250*"/>
        </Grid.ColumnDefinitions>
        <TextBlock Grid.Row="0" Grid.ColumnSpan="1" Text="第一行，第一列，占一列" Background="Red" HorizontalAlignment="Center"/>
        <Button Grid.Column="1" Grid.Row="0" Grid.ColumnSpan="3" Grid.RowSpan="2" Content="从第1行第2列开始，占两行，三列"/>
        <Button Grid.Row="2" Grid.Column="0" Grid.ColumnSpan="4" Content="第3行，从第1列开始，占4列"/>
        <Button Grid.Row="1" Name="btnAddByCode" Click="btnAddBuCode_Click">后台代码生成(第2行第1列)</Button>
    </Grid>
</Window>

（5）下图，通过C#代码实现：

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 WpfApp1
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
        private void btnAddBuCode_Click(object sender, RoutedEventArgs e)
        {
            Grid grid = new Grid();
            grid.Width = Double.NaN;//相当于在XAML中设置Width="Auto"
            grid.Height = Double.NaN;//相当于在XAML中设置Height="Auto"
            //把grid添加为窗体的子控件
            this.Content = grid;
            //列一
            ColumnDefinition cd1 = new ColumnDefinition();
            cd1.Width = new GridLength(139);
            grid.ColumnDefinitions.Add(cd1);
            //列二
            ColumnDefinition cd2 = new ColumnDefinition();
            cd2.Width = new GridLength(1, GridUnitType.Star);
            grid.ColumnDefinitions.Add(cd2);
            //列三
            ColumnDefinition cd3 = new ColumnDefinition();
            cd2.Width = new GridLength(2, GridUnitType.Star);
            grid.ColumnDefinitions.Add(cd3);
            //行一
            RowDefinition row1 = new RowDefinition();
            row1.Height = new GridLength(61);
            grid.RowDefinitions.Add(row1);
            //行二
            RowDefinition row2 = new RowDefinition();
            row1.Height = new GridLength(1,GridUnitType.Star);
            grid.RowDefinitions.Add(row2);
            //行三
            RowDefinition row3 = new RowDefinition();
            row1.Height = new GridLength(200);
            grid.RowDefinitions.Add(row3);
            //把单元格添加到grid中
            Rectangle r0c1 = new Rectangle();
            r0c1.Fill = new SolidColorBrush(Colors.Gray);
            r0c1.SetValue(Grid.ColumnProperty, 0);
            r0c1.SetValue(Grid.RowProperty, 0);
            grid.Children.Add(r0c1);
            Rectangle r1c23 = new Rectangle();
            r1c23.Fill = new SolidColorBrush(Colors.Yellow);
            r1c23.SetValue(Grid.ColumnProperty, 1);
            r1c23.SetValue(Grid.ColumnSpanProperty, 2);
            r1c23.SetValue(Grid.RowProperty, 1);
            r1c23.SetValue(Grid.RowSpanProperty, 2);
            grid.Children.Add(r1c23);
        }
    }
}

六、UniformGrid

UniformGrid就是Grid的简化版，每个单元格的大小相同，不需要定义行列集合。每个单元格始终具有相同的大小，每个单元格只能容纳一个控件，将自动按照定义在其内部的元素个数，自动创建行列，并通常保持相同的行列数。UniformGrid中没有Row和Column附加属性，也没有空白单元格。

与Grid布局控件相比，UniformGrid布局控件很少使用。Grid面板是用于创建简单乃至复杂窗口布局的通用工具。UniformGrid面板是一种更特殊的布局容器，主要用于在一个刻板的网格中快速的布局元素。

下面用XAML代码实现一个示例：

<Window x:Class="WpfApp1.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:WpfApp1"
        mc:Ignorable="d"
        Title="MainWindow" Height="300" Width="450">
    <Grid>
        <UniformGrid Rows="2" Columns="2">
            <Button>第一个（0,0）</Button>
            <Button>第二个（0,1）</Button>
            <Button>第三个（1,0）</Button>
            <Button Name="btnAddByCode" Click="btnAddBuCode_Click">第四个（1,1）</Button>
        </UniformGrid>
    </Grid>
</Window>

下面使用C#代码实现10个TextBlock的控件的布局。

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.Controls.Primitives;
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 WpfApp1
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
        private void btnAddBuCode_Click(object sender, RoutedEventArgs e)
        {
            UniformGrid wp = new UniformGrid();
            //把wp添加为窗体的子控件
            this.Content = wp;
            wp.Margin = new Thickness(0, 0, 0, 0);
            wp.Background = new SolidColorBrush(Colors.Red);
            //遍历添加Rectangles
            TextBlock block;
            for(int i = 0; i <= 10; i++)
            {
                block = new TextBlock();
                block.Text = string.Format("第{0}个",i);
                wp.Children.Add(block);
            }
        }
    }
}

WPF入门系列九——布局之DockPanel与ViewBox（四）

七、DockPanel

DockPanel 定义一个区域，在此区域中，可以使子元素通过描点的形式排列，这些对象位于Children属性中。停靠面板其实就是在 WinForm类似于Dock属性的元素。DockPanel会对每个子元素进行排序，并停靠在面板的一侧，多个停靠在同侧的元素则按顺序排列。

如果将 LastChildFill 属性设置为true（默认属性），那么无论对 DockPanel的最后一个子元素设置的其他任何停靠值如何，该子元素都将始终填满剩余的空间。若要将子元素停靠在另一个方向，必须将 ListChildFill 属性设置为 false，还必须为最后一个子元素指定显式停靠方向。

默认情况下，面板属性并不接收焦点。要强制使面板元素接收焦点，请将 Focusable属性设置为true。

注意：屏幕上 DockPanel 的子元素的位置由相关子元素的 Dock属性以及这些子元素在 DockPanel下的相对顺序确定。因此，具有相同 Dock属性值的一组子元素在屏幕上的位置可能不同，具体取决于这些子元素在 DockPanel下的顺序。子元素的顺序会影响定位，因为DockPanel会按顺序迭代其子元素，并根据剩余空间来设置每个子元素的位置。

使用XAML代码实现如下图所示效果：

<Window x:Class="WpfApp1.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:WpfApp1"
        mc:Ignorable="d"
        Title="MainWindow" Height="300" Width="450">
    <Grid>
        <DockPanel Width="Auto" Height="Auto">
            <Button DockPanel.Dock="Left" Content="1"/>
            <Button DockPanel.Dock="Top" Content="2"/>
            <Button DockPanel.Dock="Right" Content="3"/>
            <Button DockPanel.Dock="Bottom" Content="4"/>
            <Button HorizontalAlignment="Left" Name="btnAddByCode" Height="22" Width="65"
                    DockPanel.Dock="Left" Click="btnAddBuCode_Click">后台代码添加</Button>
        </DockPanel>
    </Grid>
</Window>

使用C#代码实现如下图效果：

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.Controls.Primitives;
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 WpfApp1
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
        private void btnAddBuCode_Click(object sender, RoutedEventArgs e)
        {
            DockPanel dp = new DockPanel();
            //dp.LastChildFill = true;
            dp.Width = Double.NaN;//相当于在XAML中设置Width="Auto"
            dp.Height = Double.NaN;//相当于在XAML中设置Height="Auto"
            //把dp添加为窗体的子控件
            this.Content = dp;
            //添加Rectangles
            Rectangle rTop = new Rectangle();
            rTop.Fill = new SolidColorBrush(Colors.BlanchedAlmond);
            rTop.Stroke = new SolidColorBrush(Colors.BlanchedAlmond);
            rTop.Height = 30;
            dp.Children.Add(rTop);
            rTop.SetValue(DockPanel.DockProperty, Dock.Top);
            Rectangle rLeft = new Rectangle();
            rLeft.Fill = new SolidColorBrush(Colors.Gray);
            rLeft.Stroke = new SolidColorBrush(Colors.Gray);
            rLeft.HorizontalAlignment = HorizontalAlignment.Left;
            rLeft.Height = 30;
            rLeft.Width = 30;
            dp.Children.Add(rLeft);
            rLeft.SetValue(DockPanel.DockProperty, Dock.Left);
            Rectangle rBottom = new Rectangle();
            rBottom.Fill = new SolidColorBrush(Colors.Red);
            rBottom.VerticalAlignment = VerticalAlignment.Bottom;
            rBottom.Height = 30;
            dp.Children.Add(rBottom);
            rBottom.SetValue(DockPanel.DockProperty, Dock.Bottom);
        }
    }
}

八、ViewBox

ViewBox 这个控件通常和其他控件结合起来使用，是WPF中非常有用的控件。定义一个内容容器。ViewBox组件的作用是拉伸或延展位于其中的组件，以填满可用空间，使之有更好的布局及视觉效果。

一个ViewBox中只能放一个控件。如果多添加了一个控件就会报错。如下图：

组件常用属性：

Child：获取或设置一个ViewBox元素的单一子元素。

Stretch：获取或设置拉伸模式以决定该组件中的内容以怎样的形式填充该组件的已有空间。具体设置值如下：

StretchDirection：获取或设置该组件的拉伸方向以决定该组件中的内容将以何种形式被延展。具体的设置值如下：

接下来做个示例，可以通过选择下拉框中的不同设置值，来查看不同的效果。效果如下：

<Window x:Class="WpfApp1.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:WpfApp1"
        mc:Ignorable="d"
        Title="MainWindow" Height="300" Width="450">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="250"/>
            <RowDefinition Height="auto"/>
            <RowDefinition Height="73*"/>
        </Grid.RowDefinitions>
        <Viewbox Stretch="Fill" Grid.Row="0" Name="viewBoxTest">
            <TextBox Text="通过调查发现，被阿里打假驱逐的30家售假商家中，竟有12家转战到了京东上。" />
        </Viewbox>
        <WrapPanel  Grid.Row="2">
            <StackPanel>
                <TextBlock Height="16" HorizontalAlignment="Left"  VerticalAlignment="Bottom" 
                           Width="66" Text="拉伸模式：" TextWrapping="Wrap"/>
                <ComboBox x:Name="cbStretch" Height="21" HorizontalAlignment="Left" 
                          VerticalAlignment="Bottom" Width="139" SelectionChanged="cbStretch_SelectionChanged"/>
            </StackPanel>
            <StackPanel>
                <TextBlock Height="16" HorizontalAlignment="Right"  VerticalAlignment="Bottom" 
                           Width="56" Text="拉伸方向：" TextWrapping="Wrap"/>
                <ComboBox x:Name="cbStretchDirection" Height="21" HorizontalAlignment="Right" 
                          VerticalAlignment="Bottom" Width="139" 
                          SelectionChanged="cbStretchDirection_SelectionChanged"/>
            </StackPanel>
        </WrapPanel>
    </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.Shapes;
namespace WpfApp1
{
    /// <summary>
    /// WindowViewBox.xaml 的交互逻辑
    /// </summary>
    public partial class WindowViewBox : Window
    {
        //定义cbStretch与cbStretchDirection的数据源 
        List<StretchHelper> cbStretchList = new List<StretchHelper>(); 
        List<StretchDirectionHelper> cbStretchDirectionList = new List<StretchDirectionHelper>(); 
        public WindowViewBox()
        {
            InitializeComponent();
        }
        private void BindDrp()
        { //填充各ComboBox内容 
            cbStretchList.Add(new StretchHelper() { StretchModeName = "Fill", theStretchMode = Stretch.Fill });
            cbStretchList.Add(new StretchHelper() { StretchModeName = "None", theStretchMode = Stretch.None });
            cbStretchList.Add(new StretchHelper() { StretchModeName = "Uniform", theStretchMode = Stretch.Uniform });
            cbStretchList.Add(new StretchHelper() { StretchModeName = "UniformToFill", theStretchMode = Stretch.UniformToFill });
            cbStretch.ItemsSource = cbStretchList;
            cbStretch.DisplayMemberPath = "StretchModeName";
            cbStretchDirectionList.Add(new StretchDirectionHelper() { StretchDirectionName = "DownOnly", theStretchDirection = StretchDirection.DownOnly });
            cbStretchDirectionList.Add(new StretchDirectionHelper() { StretchDirectionName = "UpOnly", theStretchDirection = StretchDirection.UpOnly });
            cbStretchDirectionList.Add(new StretchDirectionHelper() { StretchDirectionName = "Both", theStretchDirection = StretchDirection.Both });
            cbStretchDirection.ItemsSource = cbStretchDirectionList;
            cbStretchDirection.DisplayMemberPath = "StretchDirectionName";
        }
        private void cbStretchDirection_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (cbStretchDirection.SelectedItem != null)
            {
                viewBoxTest.StretchDirection = (cbStretchDirection.SelectedItem as StretchDirectionHelper).theStretchDirection;
            } 
        }
        private void cbStretch_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (cbStretch.SelectedItem != null)
            {
                viewBoxTest.Stretch = (cbStretch.SelectedItem as StretchHelper).theStretchMode;
            } 
        }
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            BindDrp();
        }
    }
    //辅助类StretchHelper 
    public class StretchHelper
    {
        public string StretchModeName { get; set; }
        public Stretch theStretchMode { get; set; }
    }
    //辅助类StretchDirectionHelper 
    public class StretchDirectionHelper
    {
        public string StretchDirectionName { get; set; }
        public StretchDirection theStretchDirection { get; set; }
    } 
}