Prism的核心功能之一就是支持模块化应用程序开发(Modular Application Development)，并且在运行时对各个模块进行动态管理。

使用Prism进行模块化开发首先要了解几个概念：

1.Module: Module是一些逻辑上相关的程序集或者资源文件的集合，在Silverlight程序中通常以xap文件为单位存在。而每一个Module中都需要有一个负责进行初始化工作以及与系统进行集成的角色，它需要实现IModule接口。IModule接口中只有一个Initialize方法，一方面这个接口将这个工程标记为一个Module，另一方面你可以在Initialize方法中实现一些逻辑，比如向容器中注册一些Service，或者将视图集成到程序中等等。

2.ModuleInfo: 在创建了一个Module之后，需要通知Prism这个Module的存在，也就是要注册一下。在Prism中，Module是以ModuleInfo的形式存在的。ModuleInfo记录了Module的信息，ModuleName属性是Module的标识符，相当于Module的ID；ModuleType是Module的AssemblyQualifiedName；DependsOn属性是该Module依赖的其它Module的ModuleName的集合，在加载该Module时，如果有依赖项没有加载的话，会先将依赖项加载；InitializationMode，有两种情况——WhenAvailable和OnDemand，当选择了WhenAvailable时，该Module会在程序启动时自动加载，如果选择了OnDemand，则会按需加载，默认情况下是WhenAvailable；Ref，存储该Module的位置，如XXX.xap；State，定义了Module从注册到加载到初始化的整个过程中的状态。

3.ModuleCatalog: ModuleCatalog实现了IModuleCatalog接口，它是ModuleInfo的容器，保存着系统中所有Module的信息，不仅会管理哪些Module需要加载，什么时候加载以什么顺序加载等问题，还要检查各个Module之间是否存在着循环依赖、是否有重复的Module等等。ModuleCatalog提供了含参构造方法和AddModule方法，可以通过代码将Module注册进去，同时也可以在xaml文件中配置好Module，然后通过ModuleCatalog.CreateFromXaml方法来加载。

4.ModuleManager: ModuleManager实现了IModuleManager接口。顾名思义就是管理Module的类。IModuleManager中含有两个方法和两个事件：Run方法会将所有InitializationMode为WhenAvailable的Module加载，然后进行初始化，初始化的工作委托给了IModuleInitializer来完成，它会获取到Module类(上面提到的实现了IModule接口的类)的实例，然后调用其Initialize方法。LoadModule方法用来加载InitializationMode为OnDemand的Module。两个事件分别用来通知下载Module的进度变化以及Module加载完成。

下面用一个示例程序来说明如何在Prism中进行模块化程序开发。

1.创建一个Silverlight Application，叫做PrismModule。

2.在Solution中添加三个Silverlight Application，分别叫做ModuleA, ModuleB, ModuleC。然后删除这三个工程中的App文件和MainPage文件。

3.在ModuleA工程下添加一个UserControl，叫做ViewA，然后再添加一个类，叫做ModuleA。并添加Microsoft.Practices.Prism和Microsoft.Practices.ServiceLocation引用。下面是ViewA和ModuleA的代码：

1
2
3
4
5
6
7
8
9
10
11
12

<UserControl x:Class="ModuleA.ViewA"
    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"
    d:DesignHeight="300" d:DesignWidth="400">
     
    <Grid x:Name="LayoutRoot" Background="White">
        <TextBlock Text="Module A" FontSize="22" />
    </Grid>
</UserControl>

1
2
3
4
5
6

public class ModuleA : IModule
{
    public void Initialize()
    {
    }
}

4.对ModuleB和ModuleC重复做步骤3的操作，只是将文本改成相应模块。

5.在PrismModule中添加对ModuleA、ModuleB、ModuleC、Prism、UnityExtensions还有Unity for Silverlight的引用，然后创建Shell和Bootstrapper。添加一个UserControl，叫做Shell；再添加一个类，叫做Bootstrapper。

Shell代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

<UserControl x:Class="PrismModule.Shell"
    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:prism="http://www.codeplex.com/prism"
    mc:Ignorable="d"
    d:DesignHeight="600" d:DesignWidth="800">
     
    <StackPanel Margin="50">
        <StackPanel Orientation="Horizontal" HorizontalAlignment="Center">
            <Border VerticalAlignment="Top" BorderBrush="Red" BorderThickness="2" Width="200" Height="100">
                <ContentControl prism:RegionManager.RegionName="RegionA" />
            </Border>
            <Border VerticalAlignment="Top" BorderBrush="Red" BorderThickness="2" Width="200" Height="100">
                <ContentControl prism:RegionManager.RegionName="RegionB" />
            </Border>
            <StackPanel>
                <Border BorderBrush="Red" BorderThickness="2" Width="200" Height="100">
                    <ContentControl prism:RegionManager.RegionName="RegionC" />
                </Border>
                <Button Content="Load Module C" Click="LoadModuleC" Width="120" Height="25" />
            </StackPanel>
        </StackPanel>
    </StackPanel>
</UserControl>

Shell.xaml.cs代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

<UserControl x:Class="PrismModule.Shell"
    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:prism="http://www.codeplex.com/prism"
    mc:Ignorable="d"
    d:DesignHeight="600" d:DesignWidth="800">
     
    <StackPanel Margin="50">
        <StackPanel Orientation="Horizontal" HorizontalAlignment="Center">
            <Border VerticalAlignment="Top" BorderBrush="Red" BorderThickness="2" Width="200" Height="100">
                <ContentControl prism:RegionManager.RegionName="RegionA" />
            </Border>
            <Border VerticalAlignment="Top" BorderBrush="Red" BorderThickness="2" Width="200" Height="100">
                <ContentControl prism:RegionManager.RegionName="RegionB" />
            </Border>
            <StackPanel>
                <Border BorderBrush="Red" BorderThickness="2" Width="200" Height="100">
                    <ContentControl prism:RegionManager.RegionName="RegionC" />
                </Border>
                <Button Content="Load Module C" Click="LoadModuleC" Width="120" Height="25" />
            </StackPanel>
        </StackPanel>
    </StackPanel>
</UserControl>

Bootstrapper代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

public class Bootstrapper : UnityBootstrapper
{
    protected override DependencyObject CreateShell()
    {
        return this.Container.TryResolve<Shell>();
    }
 
    protected override void InitializeShell()
    {
        App.Current.RootVisual = (UIElement)this.Shell;
    }
 
    protected override IModuleCatalog CreateModuleCatalog()
    {
        return new ModuleCatalog();
    }
 
    protected override void ConfigureModuleCatalog()
    {
        Type typeA = typeof(ModuleA.ModuleA);
        ModuleInfo moduleA = new ModuleInfo
        {   //  ModuleA没有设置InitializationMode,默认为WhenAvailable
            ModuleName = typeA.Name,
            ModuleType = typeA.AssemblyQualifiedName,
        };
 
        Type typeB = typeof(ModuleB.ModuleB);
        ModuleInfo moduleB = new ModuleInfo
        {
            ModuleName = typeB.Name,
            ModuleType = typeB.AssemblyQualifiedName,
            InitializationMode = InitializationMode.OnDemand,
        };
 
        Type typeC = typeof(ModuleC.ModuleC);
        ModuleInfo moduleC = new ModuleInfo
        {
            ModuleName = typeC.Name,
            ModuleType = typeC.AssemblyQualifiedName,
            InitializationMode = InitializationMode.OnDemand,
            //  ModuleC依赖于ModuleB
            DependsOn = new Collection<string> { moduleB.ModuleName },
        };
 
        this.ModuleCatalog.AddModule(moduleA);
        this.ModuleCatalog.AddModule(moduleB);
        this.ModuleCatalog.AddModule(moduleC);
    }
}

将App.xaml.cs中的Application_Startup方法改为

1
2
3
4
5

private void Application_Startup(object sender, StartupEventArgs e)
{
    Bootstrapper bootstrapper = new Bootstrapper();
    bootstrapper.Run();
}

6.现在已经有了Region，需要将各个Module中的View填充到Region中。修改ModuleA,ModuleB和ModuleC的Initialize方法。

1
2
3
4
5

public void Initialize()
{
    ServiceLocator.Current.GetInstance<IRegionManager>().
        RegisterViewWithRegion("RegionA", typeof(ViewA));
}

将其中的A改为相应的字母。运行程序，结果如下：

我们点击按钮来加载ModuleC，因为ModuleC依赖于ModuleB，所以ModuleB也一块儿加载出来了。但是这与我们预期的效果不太一致。因为一共只load了一个xap文件，用WinRAR打开看一下，发现三个Module的程序集都在其中。

在Silverlight程序中，模块化程序开发应该不仅仅体现在开发时的模块化，运行时也应该是模块化的。比如ModuleA在程序加载时就load出来，但是ModuleB和ModuleC则是在点击了按钮后才load出来的，换句话说，在没点按钮前就不应该将ModuleB和ModuleC的程序集加载进来。现在由于PrismModule项目引用了三个Module，所以程序集会被一块打包进xap文件中。我们修改一下，将对ModuleB和ModuleC的引用的Copy Local属性设置为false：

重新编译一下，再次查看xap文件，发现已经没有了ModuleB和ModuleC。

运行程序，报错。很简单，因为我们在Bootstrapper中用到了ModuleB和ModuleC，缺少了这两个dll，程序没法运行。为了解决这个问题，我们把初始化ModuleCatalog的过程改一下，不使用代码，而是使用配置文件。在Silverlight中，Prism支持使用xaml文件作为配置文件。下面在PrismModule工程下新建一个资源文件，ModuleCatalog.xaml。内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

<Modularity:ModuleCatalog xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:sys="clr-namespace:System;assembly=mscorlib"       
        xmlns:Modularity="clr-namespace:Microsoft.Practices.Prism.Modularity;assembly=Microsoft.Practices.Prism">
    
    <Modularity:ModuleInfo Ref="ModuleA.xap" ModuleName="ModuleA" 
        ModuleType="ModuleA.ModuleA, ModuleA, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
 
    <Modularity:ModuleInfo Ref="ModuleB.xap" ModuleName="ModuleB" InitializationMode="OnDemand"
        ModuleType="ModuleB.ModuleB, ModuleB, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
 
    <Modularity:ModuleInfo Ref="ModuleC.xap" ModuleName="ModuleC" InitializationMode="OnDemand"
        ModuleType="ModuleC.ModuleC, ModuleC, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null">
        <Modularity:ModuleInfo.DependsOn>
            <sys:String>ModuleB</sys:String>
        </Modularity:ModuleInfo.DependsOn>
    </Modularity:ModuleInfo>
</Modularity:ModuleCatalog>

这里大体和用代码写一致，只不过Ref属性里要写明该Module对应的是哪个xap包。Prism在Silverlight程序中使用一个叫做XapModuleTypeLoader的类来加载Module，在将Module下载之后会获取AppManifest.xaml文件，也就是说如果你的Module是个类库工程的话，会在加载时产生错误。可以将几个类库的程序集文件包装在一个xap文件中作为一个Module来使用，或者自定义一个ModuleTypeLoader。

定义完Module的配置文件后，要改写Bootstrapper。首先删除用代码配置Module的方法ConfigureModuleCatalog，然后在CreateModuleCatalog方法中替换成一下内容：

1
2
3
4
5

protected override IModuleCatalog CreateModuleCatalog()
{
    return Microsoft.Practices.Prism.Modularity.ModuleCatalog.CreateFromXaml(
        new Uri("/PrismModule;component/ModuleCatalog.xaml", UriKind.Relative));
}

再次运行程序，正常运行。

这样就达到了按需加载的目的。节约带宽是一个好处，如果产品是分模块往外卖的时候，可以由客户按需定制。

不过再打开ModuleB和ModuleC的xap文件看一下，发现里面不仅有Module本身的程序集，还包括了引用的Prism的程序集等。而这些程序集其实已经在PrismModule.xap中包含了。完全没有必要重复下载。所以可以将多余的程序集的引用的Copy Local属性设置为false，这样就瘦身成功了。(想要避免重复加载相同的文件，也可以通过在项目的Properties面板中勾选Reduce XAP size by using application library caching选项)

如果你对Module的加载到执行的整个过程感兴趣，那么Prism本身提供了一个QuickStart，既有Unity版本也有Mef版本，不要错过。

在程序中使用框架必然要有一个切入点，框架会在这里进行初始化，处理相关配置信息等。在Prism中扮演这一角色的就是Bootstrapper。

Prism提供了一个抽象基类Bootstrapper，这个类里面包含了包含了许多空的虚方法，可以重写它们添加自己的逻辑。这个基类与任何容器无关，所以可以通过继承它来实现基于特定容器的Bootstrapper，不过通常我们大可不必这样做，因为Prism默认提供了两个基于特定容器的Bootstrapper——UnityBootstrapper和MefBootstrapper，分别使用Unity和Mef来实现依赖注入。而我们需要做的工作就是在这两个类之间选择一个适合自己的，稍微配置一下就可以了。当然如果你不喜欢这两个容器或者已有的程序使用了其它容器(如Spring.Net， Castle等)，也可以通过继承Boostrapper抽象基类来实现自己的SpringBootstrapper和CastleBootstrapper。虽然UnityBootstrapper的代码看起来挺简单的，但是如果仿照这个来实现CastleBootstrapper却并不是那么容易的一件事(不信你可以试试)，所以更好的办法是用现成的。

那么Bootstrapper都做了些什么呢？

1. 创建Logger：

   执行CreateLogger方法，默认创建一个EmptyLogger，不会在任何地方输出log。当然是可以扩展的，比如你可以使用Clog来做一个适配器。

2. 创建并配置ModuleCatalog

执行CreateModuleCatalog方法，默认创建一个空的ModuleCatalog。然后执行ConfigureModuleCatalog方法，默认情况下这个方法是空的。可以重写这两个方法，加入自定义的获取ModuleCatalog的逻辑，比如在CreateModuleCatalog中可以从一个xaml文件中读取Module信息。

1
2
3
4
5

protected override IModuleCatalog CreateModuleCatalog()
{
	return ModuleCatalog.CreateFromXaml(new Uri("/AssemblyName;component/ModulesCatalog.xaml",  UriKind.Relative));
}

3. 创建并配置依赖注入容器

Prism中使用依赖注入来管理各个组件，你可以使用任何你熟悉的容器，比如Castle, Unity等。Prism中内置了对Unity以及Mef的支持，所以有两种预定义好的Bootstrapper: UnityBootstrapper和MefBootstrapper，其中分别采用UnityContainer和CompositionContainer作为依赖注入容器。以UnityBootstrapper为例，在这一步中会先调用CreateContainer方法，返回一个UnityContainer；然后调用ConfigureContainer方法，在这个方法中主要是将一些常用的类注册到容器中。

4. 配置默认的Region适配器映射

为了使xaml中的UI控件可以使用Region，需要先注册一下。Prism默认支持Region的控件类型有：TabControl, Selector, ItemsControl, ContentControl。当然你也可以通过实现IRegionAdapter接口或者直接继承RegionAdapterBase来使其它控件也支持Region。

5. 配置默认的Region 行为(Behavior)

为RegionBehaviorFactory添加一些默认的行为。这样可以扩展Region的行为。可以通过实现IRegionBehavior接口或继承RegionBehavior来自定义Region的行为，并重写ConfigureDefaultRegionBehaviors方法添加到Region。

6. 注册框架异常类型

Prism提供了ExceptionExtensions类来帮助开发人员定位异常发生的根异常。在这一步通过调用RegisterFrameworkExceptionTypes方法向ExceptionExtensions中添加新的Root Exception。

7. 创建并初始化Shell

首先调用CreateShell方法来创建一个Shell，这是一个抽象方法，通常这个方法中就是返回作为整个网站容器的页面。之后会将RegionManager attach到Shell上，然后更新定义的Regions，最后调用InitializeShell方法来初始化Shell。默认情况下这是个空方法，可以通过重写这个方法加入自定义的逻辑，可以在这个方法中将Shell作为Silverlight程序的根容器页面显示出来。

1
2
3
4
5

protected override void InitializeShell()`
{
     Application.Current.RootVisual = Shell;
}

8. 初始化Modules

调用InitializeModules方法，实际上就是调用ModuleManager.Run方法，会调用ModuleCatalog中的所有InitializationMode为WhenAvailable的Module的Initialize方法。

至此，整个容器的初始化过程就完毕了。

值得一提的还有CommonServiceLocator，这同样是Patterns & Practices小组的产品。它的作用很简单，就是统一依赖注入容器的接口，使程序不必依赖于特定的容器，只需要使用ServiceLocator，然后去间接地使用其它各种各样的容器。在Prism的内部就是使用ServiceLocator来进行管理的。所以不管使用什么样的容器，都需要提供一个实现了IServiceLocator接口的适配器，如使用Unity要提供UnityServiceLocatorAdapter，使用Mef要提供MefServiceLocatorAdapter。这样不管外部使用什么容器，内部都不需要改变。所以如果要使用Prism重头开始构架一个程序，那么在整个程序中不依赖于特定的依赖注入容器接口，而是使用ServiceLocator是一个不错的选择，这样可以在需要的情况下很容易地更换容器，只需要重写一个Bootstrapper和一个ServiceLocatorAdapter就可以了。

Prism是由微软Patterns & Practices团队开发的项目，目的在于帮助开发人员构建松散耦合的、更灵活、更易于维护并且更易于测试的WPF应用或是Silverlight应用以及Windows Phone 7应用。使用Prism可以使程序开发更趋于模块化，整个项目将由多个离散的、松耦合的模块组成，而各个模块又可以又不同的开发者或团队进行开发、测试和部署。目前Prism的最新版本是Prism 4，于2010年11月12日发布。Prism有很完整的文档以及丰富的示例程序。在这里我们仅针对于Silverlight程序的开发。

在下载Prism安装包并安装完成后，会在目标文件夹中发现很多文件。

推荐首先运行RegisterPrismBinaries.bat文件，这样在开发基于Prism的程序时可以更方便地添加引用程序集。

使用Prism之前，需要了解一些概念，下面通过一个非常简单的小程序来了解一下Prism。

1.打开Visual Studio 2010，新建一个Silverlight Application项目，并添加对Prism的引用。再创建三个Silverlight类库工程。

2.在Contract工程下新建一个接口，叫做ITextProvider。

1
2
3
4
5

public interface ITextProvider
{
	string GetText();
}

3.在其它的三个项目中都引用Contract项目。

4.在PrismStarter工程下新建一个TextProvider类并实现ITextProvider接口。

1
2
3
4
5
6
7
8
9
10
11

public class TextProvider : ITextProvider
{
 	private int i = 0;

 	public string GetText()
 	{
 	 	i++;
  	 	return string.Format("From TextProvider [{0}]", i);
 	}
}

5.删除PrismStarter项目中自动生成的MainPage.xaml，创建一个新的UserControl，叫做Shell。页面代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

<UserControl x:Class="PrismStarter.Shell"
    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:prism="http://www.codeplex.com/prism"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400">
     
    <Grid x:Name="LayoutRoot" Background="White">
        <Grid.RowDefinitions>
            <RowDefinition Height="100" />
            <RowDefinition Height="100" />
            <RowDefinition Height="100" />
        </Grid.RowDefinitions>
         
        <TextBlock FontSize="30" VerticalAlignment="Center" HorizontalAlignment="Center" Text="Prism Starter" />
         
        <ContentControl Grid.Row="1" HorizontalContentAlignment="Stretch" prism:RegionManager.RegionName="RegionA" />
 
        <ContentControl Grid.Row="2" HorizontalContentAlignment="Stretch" prism:RegionManager.RegionName="RegionB" />
    </Grid>
</UserControl>

6.在ModuleA工程中添加对Prism程序集的引用。并添加一个UserControl叫做ViewA，页面代码为：

1
2
3

<Grid :Name="LayoutRoot" Background="White">
 <TextBlock x:Name="textModuleA" FontSize="30" VerticalAlignment="Center" HorizontalAlignment="Center" /> 
</Grid>

CodeBehind中的代码为：

1
2
3
4
5
6
7
8
9
10
11
12
13

public partial class ViewA : UserControl
{
     public ViewA(ITextProvider textProvider)
     {
         InitializeComponent();

         this.Loaded += (s, e) =>
         {
            textModuleA.Text = string.Format("Module A {0}", textProvider.GetText());
         };
     }
}

7.在ModuleA工程中添加一个类叫做ModuleA，并实现接口IModule。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class ModuleA : IModule
{
    private IRegionManager _regionManager;
 
    public ModuleA(IRegionManager regionManager)
    {
        _regionManager = regionManager;
    }
 
    public void Initialize()
    {
        _regionManager.RegisterViewWithRegion("RegionA", typeof(ViewA));
    }
}

注意这里的RegionA对应于Shell页面中的RegionName。

8.在ModuleB工程中重复6、7过程，只是将A替换为B。

9.在PrismStarter工程中添加对ModuleA和ModuleB的引用。

10.在PrismStarter工程中添加一个PrismStarterBootstrapper类，并继承UnityBootstrapper。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public class PrismStarterBootstrapper : UnityBootstrapper
{
    protected override DependencyObject CreateShell()
    {
        return this.Container.TryResolve<Shell>();
    }
 
    protected override void InitializeShell()
    {   //  控制页面在初始化时显示Shell页面
        App.Current.RootVisual = (UIElement)this.Shell;
    }
 
    protected override void ConfigureModuleCatalog()
    {   //  注册Module。在实际开发中可以使用xaml做配置文件，
        //  这样就可以将PrismStarter与ModuleA和ModuleB完全解耦，也就不再需要引用这两个项目
        Type moduleAType = typeof(ModuleA.ModuleA);
        ModuleInfo moduleA = new ModuleInfo
        {
            ModuleName = moduleAType.Name,
            ModuleType = moduleAType.AssemblyQualifiedName,
        };
 
        Type moduleBType = typeof(ModuleB.ModuleB);
        ModuleInfo moduleB = new ModuleInfo
        {
            ModuleName = moduleBType.Name,
            ModuleType = moduleBType.AssemblyQualifiedName,
        };
 
        this.ModuleCatalog.AddModule(moduleA);
        this.ModuleCatalog.AddModule(moduleB);
    }
 
    protected override void ConfigureContainer()
    {   //  注册一下TextProvider，这样在通过容器请求ITextProvider时会返回TextProvider实例
        base.ConfigureContainer();
        this.Container.RegisterInstance<ITextProvider>(new TextProvider());
    }
}

11.最后一步，打开App.xaml.cs，修改Application_Startup方法

1
2
3
4
5

private void Application_Startup(object sender, StartupEventArgs e)
{
    PrismStarterBootstrapper bootstrapper = new PrismStarterBootstrapper();
    bootstrapper.Run();
}

运行程序，结果如下：

下面简单介绍一下这个小例子中涉及到的一些概念。

Bootstrapper: 在程序中使用框架需要找到一个切入点，将框架植入进去，将一部分功能委托给框架来实现。在Silverlight中使用Prism的切入点就是App.xaml.cs中的Application_Startup方法。一般来说，这个方法中只是指定页面最先加载的页面，但是我们把默认的逻辑去掉，取而代之的是Bootstrapper(在本例中就是PrismStarterBootstrapper)。当调用Bootstrapper.Run方法时，它会完成一些准备工作，如一些配置等。因此你会发现，使用Prism后，启动程序时会比正常启动要慢一些，就是因为Bootstrapper做了许多工作。

Container: 依赖注入容器。在程序中使用依赖注入的好处到处都可以找的到。在Silverlight中使用容器来管理各个组件的一个很明显的好处就是使用单例来降低内存使用。否则每次加载一个页面都需要重新创建一个也很耗费资源的。当然好处不只这些，通过容器来注入一些服务(如本例中的IRegionManager和ITextProvider)显得相当方便。

Module: Prism帮助我们把程序分解成一个个功能模块，这些功能模块就叫做Module，通常一个工程就是一个Module。由于Module彼此是独立的，但是在运行时需要将它们整合到一起，因此Prism需要知道Module的存在，这里就涉及到了ModuleCatalog, ModuleCatalog就是Module的容器，里面包含了所有Module的信息，以ModuleInfo的形式存在。ModuleInfo就是对Module的抽象，包含Module的名字，类型，依赖等一些信息。

Shell: 相当于程序的入口，初始界面，还能够提供类似ASP.Net中的母版页的功能。Shell必须由Bootstrapper创建，因为Shell需要使用的一些service，比如RegionManager等，需要在Shell显示前注册。

Region: 相当于ASP.Net中的ContentPlaceHolder(是这么叫的吧？)，起到占位符的作用，如本例中Shell中有两个Region——RegionA和RegionB，定义了两块区域。在Module的初始化过程中，通过IRegionManager将Module中的页面放进了定义好的Region中。IRegionManager负责管理Region，可以通过它向Region中注册View，进行导航等。

Prism的功能当然远不止这么简单，它还提供对MVVM模式的支持，对导航的支持等，在后续文章中会逐步介绍。希望能够通过本文让大家对Prism有一定的了解。

代码下载

.NET 中定时器的使用方法

在.NET 开发中，定时器是实现周期性任务的核心组件。根据是否依赖 UI 线程，可将其分为 “与 UI 无关联” 和 “与 UI 相关” 两大类，不同类型的定时器适用场景、线程模型及使用方式差异显著。本文将详细讲解各类定时器的特点、核心属性、正确用法及注意事项。

一、与 UI 无关联的定时器

此类定时器运行于非 UI 线程（默认使用线程池），适用于后台计算、数据同步等无需操作 UI 的场景，时间精度相对较高。

1. System.Timers.Timer

核心特点

• 支持线程同步配置，可通过SynchronizingObject指定执行线程；

• 事件驱动模式（通过Elapsed事件触发任务）；

• 适用于对执行精度有一定要求的后台任务。

关键属性修正

• AutoReset：原始描述颠倒，正确逻辑为：

  • true（默认）：定时器触发后自动重置，持续周期性执行；

  • false：定时器仅触发一次，执行后自动停止。

• SynchronizingObject：默认值为null，任务运行于线程池（CPU 自动分配线程）；若指定为 UI 控件（如 WinForms 的 Form），则任务会切换到 UI 线程执行。

• Interval：任务执行间隔（单位：毫秒），最小值为 1。

• Enabled：控制定时器是否启用（true启用，false禁用）。

正确代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

using System;

using System.Threading;

public class TimersTimerExample

{

   // 声明定时器与线程同步锁（确保多线程安全）

   private readonly System.Timers.Timer \_timer = new System.Timers.Timer();

   private readonly object \_syncRoot = new object();

   public TimersTimerExample()

   {

       // 绑定Elapsed事件（任务执行逻辑）

       \_timer.Elapsed += OnTimerTick;

       // 设置执行间隔为100毫秒

       \_timer.Interval = 100;

       // 配置为持续执行（AutoReset=true）

       \_timer.AutoReset = true;

       // 初始禁用，需手动启动

       \_timer.Enabled = false;

   }

   // 启动定时器

   public void StartTimer()

   {

       \_timer.Enabled = true;

       // 或使用\_timer.Start()（与Enabled=true等效）

   }

   // 停止定时器

   public void StopTimer()

   {

       \_timer.Enabled = false;

       // 或使用\_timer.Stop()

   }

   // Elapsed事件回调（默认运行于线程池）

   private void OnTimerTick(object sender, System.Timers.ElapsedEventArgs e)

   {

       // 加锁确保多线程下任务逻辑安全（避免并发问题）

       lock (\_syncRoot)

       {

           Console.WriteLine(\$"后台任务执行：{DateTime.Now:HH:mm:ss.fff}");

           // TODO：添加实际业务逻辑（如数据同步、日志记录）

       }

   }

}

注意事项

• 若任务逻辑涉及共享资源，需通过lock等方式保证线程安全；

• 若需在 UI 线程更新内容，需将SynchronizingObject指定为 UI 控件（如_timer.SynchronizingObject = this，需在 WinForms 环境中）。

2. System.Threading.Timer

核心特点

• 轻量级定时器，完全基于线程池实现；

• 无事件模型，通过回调函数（TimerCallback）执行任务；

• 不支持直接指定同步对象，需手动处理线程切换。

关键参数

构造函数System.Threading.Timer(TimerCallback callback, object state, int dueTime, int period)参数说明：

• callback：定时器触发时执行的回调函数；

• state：传递给回调函数的参数（无需参数时设为null）；

• dueTime：定时器启动延迟时间（单位：毫秒），0表示立即启动；

• period：任务执行间隔（单位：毫秒），Timeout.Infinite表示仅执行一次。

正确代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

using System;

using System.Threading;

public class ThreadingTimerExample

{

   // 声明线程定时器（需注意释放资源）

   private System.Threading.Timer \_timer;

   public ThreadingTimerExample()

   {

       // 初始化定时器：立即启动（dueTime=0），间隔1000毫秒执行一次

       \_timer = new System.Threading.Timer(

           callback: TimerCallback,

           state: null,

           dueTime: 0,

           period: 1000

       );

   }

   // 定时器回调函数（运行于线程池）

   private void TimerCallback(object state)

   {

       Console.WriteLine(\$"轻量级后台任务：{DateTime.Now:HH:mm:ss}");

       // TODO：添加轻量级业务逻辑（如心跳检测、缓存清理）

   }

   // 释放定时器资源（避免内存泄漏）

   public void DisposeTimer()

   {

       \_timer?.Change(Timeout.Infinite, Timeout.Infinite); // 先停止定时器

       \_timer?.Dispose(); // 释放资源

   }

}

注意事项

• 若任务执行时间超过period，线程池会分配新线程执行下一次任务，需自行控制并发；

• 不再使用时必须调用Dispose释放资源，避免线程泄漏；

• 无法直接更新 UI，需通过Dispatcher（WPF）或Invoke（WinForms）切换到 UI 线程。

二、与 UI 相关的定时器

此类定时器绑定 UI 线程，适用于 WinForms、WPF 等桌面应用的 UI 更新场景，无需手动处理线程安全，但时间精度较低（受 UI 线程繁忙程度影响）。

1. System.Windows.Forms.Timer（WinForms 专用）

核心特点

• 仅适用于 WinForms 应用，支持可视化拖拽（从工具箱拖到 Form 上）；

• 任务运行于 UI 线程，可直接更新 UI 控件（如 Label、TextBox）；

• 精度较低（约 10-55 毫秒），不适用于高时效任务。

关键属性

• Interval：执行间隔（单位：毫秒），最小值为 1；

• Enabled：控制定时器启用 / 禁用（true启用，false禁用）；

• Tick：定时器触发时执行的事件（运行于 UI 线程）。

正确代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

using System;

using System.Windows.Forms;

public partial class TimerForm : Form

{

   // 声明WinForms定时器（可通过设计器拖拽生成）

   private readonly System.Windows.Forms.Timer \_uiTimer;

   public TimerForm()

   {

       InitializeComponent();

       // 初始化定时器（代码方式，非拖拽）

       \_uiTimer = new System.Windows.Forms.Timer();

       \_uiTimer.Interval = 1000; // 1秒更新一次UI

       \_uiTimer.Tick += UITimer\_Tick;

       \_uiTimer.Enabled = true; // 启用定时器

   }

   // Tick事件（运行于UI线程，可直接操作控件）

   private void UITimer\_Tick(object sender, EventArgs e)

   {

       // 直接更新Label文本（无需线程同步）

       lblTime.Text = \$"当前时间：{DateTime.Now:HH:mm:ss}";

   }

   // 关闭窗体时释放定时器

   private void TimerForm\_FormClosing(object sender, FormClosingEventArgs e)

   {

       \_uiTimer?.Dispose();

   }

}

注意事项

• 仅能在 WinForms 项目中使用，无法跨框架（如 WPF）；

• 若Tick事件中执行耗时操作（如循环计算），会导致 UI 卡顿；

• 无需手动处理线程安全，因事件始终在 UI 线程执行。

2. System.Windows.DispatcherTimer（WPF 专用）

核心特点

• 仅适用于 WPF 应用，基于Dispatcher（WPF 线程调度器）实现；

• 任务运行于 UI 线程，支持直接更新 WPF 控件（如 TextBlock）；

• 可通过DispatcherPriority调整任务优先级（默认Normal）。

关键属性与方法

• Interval：执行间隔（类型：TimeSpan，支持秒、毫秒等单位）；

• Tick：定时器触发事件（运行于 UI 线程）；

• **Start()/Stop()**：启动 / 停止定时器（替代Enabled属性）；

• DispatcherPriority：任务在 UI 线程中的执行优先级（如Background表示后台优先级，不阻塞 UI）。

正确代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

using System;

using System.Windows;

using System.Windows.Threading;

public partial class MainWindow : Window

{

   // 声明WPF调度定时器

   private readonly DispatcherTimer \_dispatcherTimer;

   public MainWindow()

   {

       InitializeComponent();

       // 初始化定时器

       \_dispatcherTimer = new DispatcherTimer();

       // 设置间隔为1秒（使用TimeSpan）

       \_dispatcherTimer.Interval = TimeSpan.FromSeconds(1);

       // 绑定Tick事件

       \_dispatcherTimer.Tick += DispatcherTimer\_Tick;

       // 启动定时器

       \_dispatcherTimer.Start();

   }

   // Tick事件（运行于UI线程，可直接更新WPF控件）

   private void DispatcherTimer\_Tick(object sender, EventArgs e)

   {

       // 直接更新TextBlock内容

       tbTime.Text = \$"当前时间：{DateTime.Now:HH:mm:ss.fff}";

   }

   // 关闭窗口时停止定时器

   private void MainWindow\_Closing(object sender, System.ComponentModel.CancelEventArgs e)

   {

       \_dispatcherTimer?.Stop();

   }

}

注意事项

• 仅能在 WPF 项目中使用，依赖System.Windows程序集；

• 若需降低任务对 UI 的影响，可设置_dispatcherTimer.DispatcherPriority = DispatcherPriority.Background；

• 若任务耗时较长，仍会导致 UI 响应缓慢，需结合Task开启后台线程处理（处理完后通过Dispatcher.Invoke更新 UI）。

三、定时器选择指南

总结：需根据项目框架（WinForms/WPF/ 控制台）、是否操作 UI、精度要求三大因素选择定时器，避免因线程模型不匹配导致 UI 卡顿或数据安全问题。

（注：文档部分内容可能由 AI 生成）

MySQL root修改普通用户密码

MySQL GRANT：用户授权

MySQL查看用户权限

MySQL修改用户（RENAME USER）

MySQL创建用户（3种方式）

MySQL允许root远程登录_小gu的博客-CSDN博客_mysql允许root远程连接