C#入门学习-----图书阅读器(WPF 用户控件技术)

欢迎大家提出意见,一起讨论!

转载请标明是引用于 http://blog.csdn.net/chenyujing1234

需要源码请与我联系。

 

 编译平台：VS2008 + .Net Framework 3.5

        语言： C#

1、图书阅读器系统架构

1、2 系统架构设计

在这个系统中出现在的实体有图书目录、图书列表、图书、压缩格式的图书、图像缓存等。

（1） 文件夹可以直接定义为一个类。因为该对象相对固定，不同的文件夹除了名称唾位置不一样外，还可能会有一些其他变化的特性。

（2）每个文件夹包含多部书。因为图书的类型不是固定的，比如有压缩文件类型的图书和其他格式的图书，需要抽象出来实现一个接口。

（3） 每本书包含多个页面。因为每个页面的格式是不同的，因些也需要进行抽象。

（4） 每本图书会包含一个图像缓存，该缓存提供的功能相对固定，当然也可以进一步抽象。

Catalog代表一个文件夹类，它包含代表该目录下所有图书的ObservableCollection<IBook>泛型集合类。

IBook是抽象出来的代表一部图书的接口，它实现了INotifyPropertyChanged以便实现UI级别的绑定。

BaseBook是一个实现了IBook接口的类，提供了对于每本图书的基本实现。

RarBook通过派生自BaseBook类，实现了压缩格式的图书对象；

IBookItem接口是代表图书书页的接口，IBook接口包含一个类型为List<IBookItem>泛型集合，来表示一本书的所有图书页。

RarPage实现了IBookItem接口，提供了对于RarBook类型图书的书页实现。

 

1、3 项目文件夹介绍

在此图中

Dependencies文件夹包含了项目中使用到的第三方类库或程序，比如pdftohtml.exe用于将pdf文件转换为Html格式。

                          SevenZipSharp.dll用于压缩或解压缩文件，使用的时候需要7z.dll来进行压缩或解压缩。

                         WPFToolkit.dll包含一些额外的控件来丰富WPF控件。

项目根目录下的app.config是应用程序配置文件。

 

2、系统核心类的实现

这一节将介绍如何实现。主要内容涵盖了.NET的反射、多线程、操作文件和文件夹知识，以及如何使用面向对象方式设计和实现类。

2、1  实现图书目录Catalog类

图书阅读器每次在启动时，会根据在选项指定的文件路径异步加载图书到ListBox以显示书籍。

或者用户单击“打开”按钮，从弹出的打开文件窗口中选择一个文件。

Catalog会将该文件加载到其图书列表中，Catalog类要能从文件夹中枚举图书文件，也要能从特定文件中加载图书。

从图可以看出，Catalog包含实现了IBook接口的实例列表，作为其内含的图书。

因为该类不被设计用于继承或开，因此将该类指定为Internal.

 internal class Catalog

Catalog类定义了3个属性，分别用于指定文件路径、用于保存图书的列表及一个布尔值获取和设定图书变更信息。

图书列表采用泛型集合，原因是因为它采用了集合通知。

#region -----------------属性区域-----------------

		private string _bookPath = string.Empty;//文件路径
		public string BookPath   //文件路径属性
		{
			get { return _bookPath; }//返回值
			set { _bookPath = value; }//设置值
		}
		private ObservableCollection<IBook> _Books =//图书集合
            new ObservableCollection<IBook>();
		public ObservableCollection<IBook> Books  //图书集合属性
		{
		  get { return _Books; }  //返回图书列表
		  set { _Books = value; } //设置图书列表
		}

		private bool _IsChanged = false;//是否变更
		public bool IsChanged  //是否变更属性
		{
			get { return _IsChanged; }  //返回变更
			set { _IsChanged = value; } //设置变更
		}

		#endregion

 当在选项中设置好图书的路径后，每次启动程序时，会从app.config中读取设置好的图书路径，再调用重载的确Load()方式从路径中加载图书。

Load有两个重载方法。

一个接受一个文件路径作为参数，该路径将会被赋给Catalog对象的BookPath属性；

另一个Load()方法会根据该属性的值来从目录中加载图书。Load带参数的重载方法实现如下：

   public void Load(string path)//该重载方法传入一个文件路径
		{
			try
			{
				_bookPath = path;//将路径指定给BookPath属性
				Load();          //调用不带参数的重载的Load方法
			}
			catch (Exception err) //在加载过程出现错误则触发异常
			{    //调用定制的异常管理窗口显示异常信息
				ExceptionManagement.Manage("Catalog:LoadPath", err);
			}
		}

代码内部调用了Load另一个重载，如果产生异常，则会产生定制的ExceptioMamagerment类的Mange()方法来产生一个异常窗口。

Load() 方法实现了加载的所有核心逻辑。

	private void Load()  //不带参数的重载方法实现
		{
			try
			{
				string bin = System.Reflection.Assembly.//得到所保存的书签文件路径
                    GetExecutingAssembly().Location.Replace(".exe", ".bin");
				if (File.Exists(bin)) //如果存在书签
				{					
					if (LoadBooks(bin))//加载书签
					{
						bin = System.Reflection.Assembly. //得到保存的封面文件路径
                            GetExecutingAssembly().Location.Replace(".exe", ".bin2");
						if (File.Exists(bin))  //如果存在封面
						{   //使用一个后台线程异步的加载图书封面							
				Thread t = new Thread(new ParameterizedThreadStart(LoadCovers));
				t.IsBackground = true;//指定线程为后台线程
				t.Priority = ThreadPriority.BelowNormal;//指定线程优先级较低
				t.Start(bin); //开始执行线程，并传入Bin参数
						}
					}
					else  //如果加载书签失败
						ParseDirectoryThread();//通过分析文件夹重建书签
				}
				else //如果书签文件不存在
				{
                    ParseDirectoryThread();//通过分析文件夹重建书签
				}
			}
			catch (Exception err) //产生异常
			{   //显示一个异常信息窗口，列明异常信息
				ExceptionManagement.Manage("Catalog:Load", err);
			}
		}

代码首先使用System.Reflection.Assembly.GetExecutingAssembly返回当前执行的程序集，获取其Location属性的值，

即程序集的位置。

调用Replace()方法将exe扩展名替换为bin扩展名，得到一个与可执行文件相同的.bin文件，这个文件

保存了图书的文件和文件夹信息，该信息作为书签以二进制格式保存，如果该文件存在，则调用LoadBooks()方法加载书签；

另一个与可执行文件具有相同文件名，扩展名为bin2的文件，保存的是每本图书的封面，如果存在，代码使用一个参数线程后台加载图书

封面信息。

 

2、2 加载书签信息

图书阅读器尽量保存用户所读过的书的历史信息，以便下次打开软件时，能直接从前一次的位置开始阅读。

因此在每次关闭软件时，会调用Save()方法来保存这些信息。LoadBooks()方法将从保存的二进制文件中恢复历史记录。

private bool LoadBooks(string fileName)//从文件中加载图书集合信息
		{
			bool result = true; //默认结果值
			IFormatter formatter = new BinaryFormatter();//实例化二进制格式化器
			Stream stream = new FileStream(fileName,  //创建一个FileStream打开文件流
				FileMode.Open,
				FileAccess.Read,
				FileShare.None);
			try
			{
				//从流中反序列化出文件目录
				string booksFrom = (string)formatter.Deserialize(stream);
				//如果图书路径与当前目录位于不同的路径
				if (this._bookPath != booksFrom || !Directory.Exists(this._bookPath))
				{   //新建一个books集合类
					this._Books = new ObservableCollection<IBook>();
					result = false;//加载失败
				}
				else //如果是同一个文件夹
				{
					//首先反序列化出图书数目
					int count = (int)formatter.Deserialize(stream);
					for ( int i = 0; i < count; i++ ) //循环图书数目
					{
						//反序列化出每个文件的文件路径
						string filePath = (string)formatter.Deserialize(stream);
						long size = (long)formatter.Deserialize(stream);//文件大小
						int nbPages = (int)formatter.Deserialize(stream);//页数
						string bookmark = (string)formatter.Deserialize(stream);//书签
                        bool isread= (bool)formatter.Deserialize(stream);//是否阅读
						FileInfo file = new FileInfo( filePath );//获取文件信息
						if( file.Exists )//如果文件存在
						{
							IBook bk = null;//初始化实现IBook接口的对象
                            //如果书签过滤设置中包含与文件一致的扩展名
                            if (Properties.Settings.Default.BookFilter.
                                Contains(file.Extension.ToUpper()))
                                bk = (IBook)new RarBook(file.FullName, false);//返回一个新的Rar书本对象
							bk.Bookmark = bookmark;//指定书签
							bk.Size = size;        //指定大小
							bk.NbPages = nbPages;  //指定页数
                            bk.IsRead = isread;    //指定是否阅读
							this._Books.Add(bk);   //加载到书签列表
						}
					}
				}
			}
			catch( Exception err ) //如果出现加载异常
			{   //在异常处理窗口中显示异常信息
				ExceptionManagement.Manage("Catalog:LoadBooks", err);
			}
			finally
			{
				stream.Close(); //文件流使用完成后要关闭以释放非托管资源
			}
			return result;      //返回结果
		}

LoadBooks要根据保存的顺序从二进制文件中反序列化保存的数据，因此代码首先实例化了一个二进制序列化对象

BinaryFormatter，然后使用FileStream打开文件，使用二进制序列化对象一步一步地进行反序列化。

如果文件的路径与当前反序列化的文件路径不一样，那么系统会初始化一个新的Books集合，并返回加载失败。

如果位于同一文件夹，将继续反序列化流中保存的图书，首先得到图书的数量，然后循环依次反序列化图书文件的详细信息。

如果图书文件存在，则实例化一个新的RarBook 对象，并使用反序列化的信息初始化这个对象，然后加载到图列表中。

2、3 加载图书封面

加载图书封面的LoadCovers() 方法，该方法将在一个后台线程中实现封面的加载，封面将被异步地加载到用户界面的ListBox中。

因为封面资料被保存到另一个二进制文件中，也需要使用反序列化从流中加载信息。

public void LoadCovers(object fileName)//加载封面
		{
			IFormatter formatter = new BinaryFormatter();//实例化二进制格式化器
			Stream streamBin =   //加载封面文件
                new FileStream((string)fileName,
				FileMode.Open,
				FileAccess.Read,
				FileShare.None);
			try
			{   //反序列化图书数目
				int count = (int)formatter.Deserialize(streamBin);
				for (int i = 0; i < count; i++)  //遍历图书数目
				{    //反序列化文件路径
					string filePath = 
                        (string)formatter.Deserialize(streamBin);
                    //反序列化内存流，这个过程即便不存在内存流也需要进行反序列化
                    MemoryStream coverStream = 
                        (MemoryStream)formatter.Deserialize(streamBin);
					foreach (IBook book in this._Books)  //遍历图书列表
					{
						if (book.FilePath == filePath) //如果文件路径相同
						{
							MemoryStream stream2 = new MemoryStream();//新建一个内存流
							coverStream.WriteTo(stream2);//将封面流写入内存流中 
							coverStream.Flush();         //刷新封面流
							coverStream.Close();         //关闭封面流
							stream2.Position = 0;        //重定位内存流
                            //调用Invoke方法，在与UI相同的线程中异步的更新图片
							Application.Current.Dispatcher.Invoke
                                (DispatcherPriority.Normal, (ThreadStart)delegate
							{
								BitmapImage myImage = new BitmapImage();
								myImage.BeginInit();  //开始更新
								myImage.StreamSource = stream2;//指定流来源
								myImage.DecodePixelWidth = 70;//指定图片宽度
								myImage.EndInit();           //结束更新
								book.Cover = myImage;   //将图书封面指定为该BitmapImage
							});
							coverStream = null;  //释放封面流
							stream2 = null;      //释放内存流
						}
					}
				}
			}
			catch (Exception err)//如果产生异常
			{   //在与UI相同的线程中调用异常显示窗口
				Application.Current.Dispatcher.Invoke
                    (DispatcherPriority.Normal, (ThreadStart)delegate
				{   //使用自定义的ExceptionManagement类
					ExceptionManagement.Manage("Catalog:LoadCovers", err);
				});
			}
			finally
			{
				streamBin.Close();//关闭文件流以释放资源
			}
		}

LoadCovers()在后台线程中执行，而该线程与UI不处于同一线程，要调用UI线程中的方法，必须使用Dispatcher.Invoke()方法，

传入要执行的方法。

 2、4 多线程图书搜索

现在回到Load()方法中，如果在加载书签失败或不存在书签文件，那么Load()方法会调用ParseDirectoryThread()方法在一个后台

线路中递归文件夹，得到书签信息。

	internal void ParseDirectoryThread()//使用后台线程获取图书书签信息
		{
			try
			{
				Books.Clear();//清除图书列表
                Thread t = new Thread  //在后台线程中调用ParseDirectoryRecursive方法
                    (new ParameterizedThreadStart(ParseDirectoryRecursive));
				t.IsBackground = true;  //指定为后台线程
				t.Priority = ThreadPriority.BelowNormal;//指定线程优先级别
				t.Start(_bookPath); //为线程方法传入文件夹路径
			}
			catch (Exception err)  //如果产生异常
			{   //调用自定义的异常信息窗口
				ExceptionManagement.Manage("Catalog:ParseDirectoryThread", err);
			}
		}

ParseDirectoryThread方法首先清除图书列表，然后实例化一个参数化的线程，在后台线程中调用ParseDirectoryRecursive递归解析

传入的文件夹路径。该方法实现了重获书签信息的核心逻辑。

internal void ParseDirectoryRecursive(object path)//递归获取图书书签信息
		{
			try
			{   //实例化DirectoryInfo对象
				DirectoryInfo directory = new DirectoryInfo((string)path);
				if (!directory.Exists)//如果目录不存在
				{   //在UI线程中显示提示信息
                    Application.Current.Dispatcher.Invoke
                        (DispatcherPriority.Normal, (ThreadStart)delegate
                    {
                        MessageBox.Show("目录不存在! 请检查选项对话框");
                    });
					return; //退出方法
				} //如果目录存在，则调用GetFiles方法获取目录下所有的文件
				foreach (FileInfo file in directory.GetFiles("*.*"))
				{   //判断图书文件扩展名列表中是否包含指定文件的扩展名
                    if (Properties.Settings.Default.
                        BookFilter.Contains(file.Extension.ToUpper()))
					{   //如果包含，则在UI线程中实例化RarBook对象
						Application.Current.Dispatcher.Invoke
                            (DispatcherPriority.Background, (ThreadStart)delegate
						{   //实例化一个新的RarBook对象
                            IBook bk = (IBook)new RarBook(file.FullName, true);
							bk.Size = file.Length; //指定文件大小
							Books.Add(bk);         //添加到列表中
							this.IsChanged = true;//设置Ischanged状态为true
						});
					}
				}
				foreach (DirectoryInfo dir in  //循环遍历目录下的子目录
                    directory.GetDirectories("*", SearchOption.TopDirectoryOnly))
				{  //通过递归调用自身搜索子目录中的文件
					ParseDirectoryRecursive(dir.FullName);
				}
			}
			catch (Exception err)  //如果产生了异常
			{   //在UI线程中调用ExceptionManagement的Manage方法
				Application.Current.Dispatcher.Invoke
                    (DispatcherPriority.Normal, (ThreadStart)delegate
				{   //在UI线程中显示异常信息
					ExceptionManagement.Manage("Catalog:ParseDirectoryRecursive", err);
				});
				return;//方法返回
			}
			return; //方法返回
		}

ParseDirectoryRecursive是一个不断调用自身的过程。

因为Books这个集合是一个泛型的ObservableCollection<IBook>类，该类将要与UI进行绑定来自动更新UI，

而IBook实现了INotifyPropertyChanged接口。同样地，在一本书的属性信息变化时触发UI的变更，对于Books集合的

增删改必须要与UI处于同一线程，因此使用了Dispatcher 的Invoke()方法。

2、5 保存图书信息

public void Save()//保存封面和书签信息
		{
			try
			{
				if (IsChanged) //如果图书列表发生变化
                {   //移除没有封面的图书					
					RemoveDirtyBooks();
					//保存书名和书签
					string bin = System.Reflection.Assembly.//获取书签文件名
                        GetExecutingAssembly().Location.Replace(".exe", ".bin");
					SaveBooks(bin);//调用SaveBooks方法保存书签					
					bin = System.Reflection.Assembly.  //获取封面文件名
                        GetExecutingAssembly().Location.Replace(".exe", ".bin2");
					SaveCovers(bin);//调用SaveCovers方法保存封面信息
				}
			}
			catch (Exception err)//如果触发异常
			{   //显示异常提示窗口
				ExceptionManagement.Manage("Catalog:Save", err);
			}
		}

 

2、6 刷新图书列表

在UI主线程中，当用户单击“刷新”按钮时会调用Catalog 类的Refresh() 方法，因为图书阅读器是基于文件和文件夹这种存储模式，文件和文件夹可能会发生变化。

那么通过刷新机制可以从事Books集合中移除不存在的文件或文件夹。Refresh使用一个后台线程调用RefreshThread()方法。

 // 从目录中加载图书列表
        public void Refresh()
        {
            try
            {
                // 带参数的线程委托
                Thread t = new Thread(new ParameterizedThreadStart(RefreshThread));
                t.IsBackground = true;
                t.Priority = ThreadPriority.BelowNormal;
                t.Start(_bookPath);
            }
            catch (Exception err)
            {
				ExceptionManagement.Manage("Catalog:Refresh", err);
            }
        }

 

 internal void RefreshThread(object o)//刷新图书列表
        {
            try
            {   //首先，刷新己经不存在的图书  
                // List也为泛型类型
                List<IBook> temp = new List<IBook>();
                foreach (IBook book in this._Books)
                {   //循环遍历判断图书文件是否存在
                    if (!File.Exists(book.FilePath))
                        temp.Add( book );//不存在则加入到移除图书列表
                }
                foreach (IBook book in temp)//遍历要移除的图书列表
                    Application.Current.Dispatcher.Invoke  //  因为refresh是在后台，而我们的移除的内容是在用户界面，
                                                           // 所以要用主线程中的方法
                        (DispatcherPriority.Normal, (ThreadStart)delegate
                    {  
                        //在UI线程中移除图书
                        // 因为_Books是与ListBox绑定的变量，这样就能在界面上删除图书
                        _Books.Remove(book);
                    });
                //重新从文件中加入图书列表
                ParseDirectoryRecursiveWithCheck(_bookPath);
            }
            catch (Exception err)//如果产生异常
            {
                Application.Current.Dispatcher.Invoke
                    (DispatcherPriority.Normal, (ThreadStart)delegate
                {   //在UI线程中显示异常处理窗口
                    ExceptionManagement.Manage("Catalog:RefreshThread", err);
                });
            }
        }

代码首先实例化一个新的List<IBook>泛型列表，循环Books集合，判断指定的图书对应的文件是否存在，如果不存在则加入到List<IBook>中准备移除，

然后在UI线程中进行循环移除；

然后调用ParseDirectoryRecursiveWithCheck()方法，该方法与ParseDirectoryRecursive类似，是一个递归方法，该方法主要不同的是调用了

BookExist() 方法来判断图书的文件路径与当前的文件路径是否一致。

2、7  定义图书接口IBook

BookReader当前支持的图书类型有限，仅RarBook这一类，但是系统在最初架构时，已经提供了弹性方式允许将来扩充

多种图书文件格式，其BaseBook实现了IBook接口，开发人员可以通过派生自BaseBook类来实现多种格式图书类。

 

BaseBook实现了IBook接口，IBook接口又被Catelog引用，使用这种基于接口的方法可以实现程序间的解耦，

使程序具有良好的可扩充性。

internal interface IBook : INotifyPropertyChanged
	{
		string FileName { get; }//文件名称
		int NbPages { get; set; }//图书页数
		long Size { get; set; }  //文件大小
        bool IsRead { get; set; } //是否阅读
		string Bookmark { get; set; }//书签
		BitmapImage Cover { get; set; } //封面
		IBookItem CurrentPage { get; set; }//书页
        string FilePath { get; set; }  //文件路径//书页集合  //图像缓存
		BitmapImage GetCurrentPageImage();//当前书页
		void GotoMark();  //定位书签
		bool GotoNextPage();//转到下一页
		bool GotoPage(IBookItem page);//定位到指定页
		bool GotoPreviousPage();//转到上一页
		void Load(); //加载图书
		void ManageCache();//管理缓存
		void SetMark(); //设置书签
		void UnLoad();  //卸载图书
	}

IBook接口定义了一本书基本属性和方法，该接口派生自INotifyPropertyChanged接口，当图书信息发生变化时，

可以向UI触发属性变更通知。

2、8 图书基类BaseBook

BaseBook也要实现INotifyPropertyChanged接口的成员员，BaseBook类与其他类的关系如下：

RarBook从BaseBook基类派生，提供了对于Rar格式图书的实现。BaseBook包括ImageCache图像缓存。

BaseBook的Pages包含实现了IBookItem接口的对象集合，CurrentPage用于显示当前的图书页面。

该类重载了构造函数，提供了一个接收文件路径的构造函数，当文件路径发生变化时，会触发INotifyPropertyChanged接口

中定义的变更通知。

public BaseBook(string filePath)
		{
			_filePath = filePath; //得到文件路径
			RaisePropetyChanged("FilePath");//触发文件路径变更通知
			RaisePropetyChanged("FileName");//触发文件变更通知
		}

下面从3个方面介绍BaseBook实现的功能：

（1） 实现书签功能： BaseBook允许用户定义或跳转到书签，提供书签列表功能。

public void SetMark()
		{   //将当前页面的路径赋给Bookmark
			Bookmark = _CurrentPage.FilePath;
		}
		public void GotoMark()
		{   //如果_Bookmark路径不为空
			if (!string.IsNullOrEmpty(_Bookmark))
				foreach (IBookItem pg in Pages)
				{   //如果页面路径与书签路径相同
					if( pg.FilePath == _Bookmark )
						_CurrentPage = pg; //指定当前页面
				}
			}
		}

SetMark()方法主要是记录当前页面的文件路径，该值被赋给Bookmark属性，而BookMark属性会触发属性变更通知，以便UI能够知晓变化。

（2）  实现页面导航：BaseBook提供上一页、下一页或定义到指定页。

public bool GotoPage( IBookItem page )//定位到指定页面
		{   //循环遍历页面
			foreach (IBookItem pg in Pages)
			{   //如果页面与指定页面一致
				if (pg == page)
				{   //设置当前页面
					_CurrentPage = pg;
					return true;//返回设置成功
				}
			}
			return false;//否则设置失败
		}
		public bool GotoNextPage()//跳转到下一页面
		{   //得到当前页面的索引值
			int next = Pages.IndexOf(_CurrentPage);
			if (next >= Pages.Count-1)//判断是否越界
				return false; //如果越界则返回
			else
			{
				next = next + 1; //让索引值加1转到下一页
				_CurrentPage = Pages[next];//设置当前页为下一页
				return true; //返回设置成功标志
			}
		}
		public bool GotoPreviousPage()//跳转到上一页面
		{   //得到上一页面的索引值
			int next = Pages.IndexOf(_CurrentPage);
            if (next == 0) //如果值为0则不能再上一页
                return false;//返回导航失败标记
            else
            {
                next = next - 1;//减少一页
                _CurrentPage = Pages[next];//设置当前页为上一页
                return true;  //返回设置成功标记
            }
		}

 

（3） 实现基本的图像缓存： BaseBook提供了基本的缓存功能。

2、9 图书页面接口IBookItem的定义

internal interface IBookItem //图书页面接口
	{
		string FilePath { get; }//文件路径
		string FileName { get; }//文件名称
	}

 

 3、设计BookReader用户主界面

3、1 设计系统主界面

WPF用户界面的设计与传统的Winodw Forms的UI设计有了明显的区别，在WPF中，UI设计通常使用

而局软件进行UI布局。

BookReader的主界面使用一个Grid控件将整个面板分为4行。因了BookReader要显示圆滑的边框，所以需要将主窗口的背景设置为透明色，

并且去掉Windows自带的标题栏。在声明属性时，将其Backgroud属性设置为Transparent，设置WindowsStyle为None。

添加一个Grid控件，使用该Grid将覆盖整个客户端区域使用RowDefinitions集合编辑器将这个grid划分为4行。

 

 

因为将WindowStyle属性设置为None后，需要为主界面自己添加最小化、最大化和关闭按钮。

窗体阅读区域位于第3行，在该行内部又嵌入一个Grid，这个Grid将中间分为3列，分别用于旋转ListBox,Splitter和一个用来显示书面的图像的用户控件。

 

3、2 实现主窗口样式的绑定

在主界面中，大多数控件的Style使用了DynamicResource这个动态资源关键字绑定到了样式。

在WPF中，资源分为以下两类：

（1）静态资源：使用StaticResource进行指定，静态资源在第一次编译后即确定其对象或值，之后不可修改。

（2）动态资源：使用DynamicResource指定，在运行时决定，当运行时才会到资源目录中查找其值。

例如，在主界面XAML文件中，Border用来为主界面实现圆角边框，使得窗体看起来很圆滑，一些按钮具有特别样式，都使用

DynamicResource进行设定。

 

那么这些资源是定义在哪里呢？打开App.xaml文件，就可以看到在应用程序集，使用ResourceDictionary合并了几个资源文件。

3、3 实现图书列表界面

图书列表信息被绑定到一个ListBox控件上，图书阅读面板上使用了一个控件来显示图片信息，中间使用一个自定义的GridSplitterExpander控件来实现分割条。

ListBox控件的DataContext将绑定到Catalog对象的Books集合上，用来显示图书封面和图书详细信息。

当用户双击图书时，在图书阅读界面显示图书，该ListBox控件被放在一个Grid的左侧列中。

 

每当加载图书目录时，ListBox会被绑定到Catalog的Books集合上，加载图书目录的代码写在LoadCatalog() 方法内部，

该方法在主窗体加载时会被调用。

private void LoadCatalog()
		{
			//加载图书目录
			_Catalog.Load(Properties.Settings.Default.Catalog);
            //指定ListBox控件的数据绑定
			CatalogListBox.DataContext = _Catalog.Books;
			this.Splitter.Title = //指定中间分割条的文本
                string.Format("CATALOG ({0} book(s))", _Catalog.Books.Count);
		}

CatalogListBox的DataContext被指定到_Catalog.Books集合，然后ListBox的ItemSource指定到了集合中的元素，

具体的呈现交给了命名样式CatalogCoverStyle。（CatalogCoverStyle通过下图指定）

该样式位于Resources文件夹下的Shared.xmal的定义中，指定了ListBox的数据模板和而已面板。

（Shared.xmal是在App.xml中被合并到资源中了）

Shared.xmal中定义了三部分内容：

（1）ListBox的整体数据模板

（2）单个元素指定的样式

（3）BaseBook的数据模板

 

3、4 实现图书阅读界面

图书阅读面板中间是一个可折叠的自定义控件，该控件也显示了当前打开图书的页数，可以单击上面的方向箭头进行折叠和展开。

分割条与PageView控件的声明XAML如下：

 

4、实现用户界面功能

本节将介绍如何调用核心层中的功能来实现阅读器的运行。

4、1 实现工具按钮事件

最大化和最小化只是改变主窗体的WindowState来控制；

对于退出按钮，可以直接调用主窗体的Close()方法来关闭窗体，实现如下：

  //标题栏的关闭按钮事件处理代码
        private void closeButton_Click(object sender, RoutedEventArgs e)
        {
            this.Close();//Close方法关闭主窗体
        }
        //标题栏的最大化按钮事件处理代码
        private void maximizeButton_Click(object sender, RoutedEventArgs e)
        {   //首先判断当前WindowState的状态是否是最大化
            if (this.WindowState == WindowState.Maximized)
                 //如果为最大化，则设置为标准样式
                this.WindowState = WindowState.Normal;
            else //否则设置为最大化样式
                this.WindowState = WindowState.Maximized;
        }
        //将窗口最小化事件处理代码
        private void minimizeButton_Click(object sender, RoutedEventArgs e)
        {
            this.WindowState = WindowState.Minimized;//指定最小化
        }

4、1、1、页面适应按钮

调整宽度和高度的按钮，其事件处理代码通过调用用户控件PageViewer的方法来实现，代码如下：

  private void btnFitWidth_Click(object sender, RoutedEventArgs e)
        {  //通过设置PageViewer控件的FitWidth属性来设置宽度
			this.SimplePageView.FitWidth();
        }
        private void btnFitHeight_Click(object sender, RoutedEventArgs e)
        {   //通过设置PageViewer控件的FitHeight来设置宽度
			this.SimplePageView.FitHeight();
        }		

4、1、2 打开图书按钮

///打开一个不在当前文件夹的外部文件		
		private void btnOpen_Click(object sender, RoutedEventArgs e)
		{
			using (System.Windows.Forms.OpenFileDialog  //实例化一个OpenFileDialog对象
                browser = new System.Windows.Forms.OpenFileDialog())
			{
				if (browser.ShowDialog() == //显示打开文件对话框
                    System.Windows.Forms.DialogResult.OK)
				{   //调用Catalog的Open方法打开文件，将返回的IBook实例加载到图书列表
					LoadBook( (IBook)_Catalog.Open(browser.FileName) );
				}
			}
		}       

在代码中，使用using语句块实例化一个OpenFileDialog对象，在超过该using语句块的作用域时，该对象将自动

释放掉。根据获取到的所要打开的文件名， 调用Catalog对象的Open() 方法打开该文件。

然后调用LoadBook将打开的文件加载到PageViewer控件及图书列表中。

LoadBook是定义在主窗体中的一个辅助方法，该方法专用于加载指定IBook对象实例的图书到UI对象PageViewer控件中。

	//加载一部指定的图书
		private void LoadBook( IBook book )
		{
			try
			{
				if (_CurrentBook != null)//首先卸载CurrentBook图书
					_CurrentBook.UnLoad();
				_CurrentBook = book;//将当前图书指定为传入的图书
				_CurrentBook.Load();//加载图书到图书对象中
                this.SimplePageView.Scale = 1.0;//指定缩放比率
                //指定当前图书页面图像
                this.SimplePageView.Source = _CurrentBook.GetCurrentPageImage();
                //指定当前Label控件显示图书路径
				this.PageInfo.Content = _CurrentBook.CurrentPage.FilePath;
                //滚动到图书的开始位置
				this.SimplePageView.ScrollToHome();
			}
			catch (Exception err)
			{   //如果产生异常，显示异常信息窗口
				ExceptionManagement.Manage("Main:LoadBook", err);
			}
		}

 

在代码中，产生指定_CurrentBook对象，当前一本书加载进来时，将设置_CurrentBook对象，然后将PageViewer控件的Source

指定从GetCurrentPageImage()方法返回的当前页面。

4、1、3 选项按钮

private void btnOptions_Click(object sender, RoutedEventArgs e)
		{ //显示选项对话框
			try
			{   //实例化选项对话框
				OptionWindow dlg = new OptionWindow();
				if (dlg.ShowDialog() == true)//显示对话框
				{   //如果变更了属性设置
					if (dlg.NeedToReload)
					{  //重新加载整个图书
						LoadCatalog();
					}
				}
			}
			catch (Exception err)//出现异常
			{   //显示异常窗口
				ExceptionManagement.Manage("Main:btnOptions_Click", err);
			}
		}

4、1、4 全屏按钮

private void btnFullScreen_Click(object sender, RoutedEventArgs e)
		{
			try
			{
				if (_isFullSreen)//当前是否全屏的布尔字段
				{   //恢复全屏状态
					this.WindowState = WindowState.Normal;
					_isFullSreen = false;  //重置全屏布尔字段
                    Splitter.IsExpanded = false;
				}
				else //如果当前不是全屏状态
				{   //将窗口最大化
					this.WindowState = WindowState.Maximized;
					_isFullSreen = true;//设置全屏状态
                    Splitter.IsExpanded = true;//将分割条进行折叠
				}
			}
			catch (Exception err)//如果出现错误 
			{   //显示异常并记录错误信息
				ExceptionManagement.Manage("Main:btnFullScreen_Click", err);
			}
		}

将WindowState设置为Maximized来使窗口最大化而实现全屏，同时使自定义的控件Splitter控件进行折叠以模拟全屏效果。

 

4、2 实现上下文菜单事件处理

 

 

添加标签、定位到标签和移除标签菜单项的实现代码如下：

 

 //将当前图书的当前页面设置为书签
		private void MenuItem_BookMark(object sender, RoutedEventArgs e)
		{
			try
			{
				if (_CurrentBook != null)//仅在当前图书不空才能设置书签
				{
					_CurrentBook.SetMark();//将当前图书页面的路径指定为当前书签
					_Catalog.IsChanged = true;//设置书签变更标志 
				}
			}
			catch (Exception err)
			{   //如果产生异常显示异常信息
				ExceptionManagement.Manage("Main:MenuItem_BookMark", err);
			}
		}
        //如果当前图书有设置书签，则定位到当前书签        
		private void MenuItem_GotoBookMark(object sender, RoutedEventArgs e)
		{
			try
			{   //判断当前图书是否是在图书列表中选择图书
				if (_CurrentBook != (IBook)CatalogListBox.SelectedValue)
				{   //如果不是，则重新加载选中的图书
					LoadBook((IBook)CatalogListBox.SelectedValue);
				}
				_CurrentBook.GotoMark();//定位到书签页面
                //获取当前页面的图书
                this.SimplePageView.Source = _CurrentBook.GetCurrentPageImage();
				this.SimplePageView.ScrollToHome();//滚动到页开始处
			}
			catch (Exception err)
			{   //如果有异常显示异常信息
				ExceptionManagement.Manage("Main:MenuItem_GotoBookMark", err);
			}
		}
        //清除书签
		private void MenuItem_ClearBookMark(object sender, RoutedEventArgs e)
		{
			try
			{   //清除当前选中图书的书签
				((IBook)CatalogListBox.SelectedValue).Bookmark = string.Empty;
				_Catalog.IsChanged = true;//设置IsChanged标志以便保存书签
			}
			catch (Exception err)
			{  //如果产生异常，显示异常处理信息
				ExceptionManagement.Manage("Main:MenuItem_ClearBookMark", err);
			}
		}

 

书签只能对当前图书进行设置，因此需要具有_CurrentBook值，调用 SetMark()方法用于将当前阅读的路径记录到内部的BookMark属性中。

IsChanged属性设置为true后，在保存书签到文件时，会保存到文件中去。

UI端如何在图书列表上添加一个书签图标和阅读外观呢？

可以在XMAL中将一个Border和BitmapImage控件绑定到了IsRead和Bookmark属性上，可以参考Shared.xaml资源文件中的

CatalogCoverStyle 样式定义。

 

4、3  创建PageViewer用户控件

该控件在内部使用一个Image控件来显示图书，为了使图书阅读器与目前市面上流行的阅读器软件具有类似的功能，

该Image控件需要处理和种鼠标和键盘事件来实现图书阅读器效果。

 

4、4 PageViewer 控件属性定义

PageViewer定义了3个属性，这3个属性用来改变PageViewer的内部行为。

  //指定自动缩放类型
        public AutoFit AutoFitMode
        {
            get { return  //获取自动缩放属性值
                (AutoFit)Properties.Settings.Default.UseAutoFit; }
        }
        //指定缩放的大小属性
		public double Scale
        {
            get { return _scale; }
            set
            {
                _scale = value;
                UpdateScale(); //更新屏幕缩放
            }
        }
		//要显示的图像源
        public ImageSource Source
        {
            get { return this.PageImage.Source; }
            set { this.PageImage.Source = value; }
        }
        

在代码中，AutoFitMode属性根据用户在选项面板中的设置来指定自动缩放的类型；

Scale属性用来指定缩放大小，主要根据用户在右下角的Slider控件的返回值来设定Image控件的缩放大小；设置后会调用UpdateScale()方法，

该方法将使用ScaleTransform对象为Image控件设置缩放变换；

/// <summary>
		/// 更新图像控件的缩放，并触发事件
		/// </summary>
        private void UpdateScale()
        {
            this.scaleTransform.ScaleX = _scale;//指定x缩放值
            this.scaleTransform.ScaleY = _scale;//指定y缩放值
            //指定变换中心点
            this.scaleTransform.CenterX = 0.5;
            this.scaleTransform.CenterY = 0.5;
            //触发变换事件
			RaiseZoomChanged();
        }

 

UpdateScale通过设置缩放变换的ScaleX、ScaleY指定缩放大小，最后调用RaiseZoomChanged解发缩放路由事件。

4、5 定义PageViewer控件路由事件

路由事件是一种可以针对元素树中的多个侦听器（而不是针对引发该事件的对象）调用处理程序的事件。

在WPF中，对用户界面进行布局与传统的Windows Forms有些不一样，在WPF中，用户界面是由一个对象树组成，称为逻辑树。在Vs2010中，用户可以在大纲视图

中看到整棵逻辑树。在WPF中，还有一棵树，称为可视树。可视树将所有的节点打散到核心的可视组件中，而不是将每个元素当作一个黑盒。

例如一个ListBox，在逻辑树上是一个单独的元素，但是在视觉上是由多个元素组成的。因为WPF中的这种特性，路由事件设计的目的是专门用于在元素树中使用的事件，

当路由事件解发后，事件可以向上或向下遍历视觉树和逻辑树，使用一种简单而持久的方式在每个元素上解发。

 

 

WPF中的路由事件是一个可传递的事件，事件可以沿着视觉树向上和向下传递，因此事件可以被多个视觉元素捕获来决定是否处理。

RaiseZoomChanged事件将在MainWindow.xmal中被订阅，以便在图像缩放后，能触发缩放滑动块自动切换位置行为。

在主窗体的XMAL声明中，关联了ZoomChanged事件，代码如下：

ZoomChanged 是一个路由事件，因此事件在解发后会以冒泡的形式通知其视觉树中的上层元素，使得视觉树的其他元素有机会处理该事件。

SimplePageView_ZoomChanged的代码如下：

/// <summary>
		/// 当页面缩放后更新滑动条控件的位置
		/// </summary>
		private void SimplePageView_ZoomChanged
            (object sender, PageViewer.ZoomRoutedEventArgs e)
		{
			this.zoomSlider.ValueChanged -= //清除滑块控件的事件处理器
                new RoutedPropertyChangedEventHandler<double>(this.Slider_ValueChanged);
			this.zoomSlider.Value = Math.Round( e.Scale * 100, 0);//更新滑块的值
			this.zoomSlider.ValueChanged += //重新关联滑块的事件处理器
                new RoutedPropertyChangedEventHandler<double>(this.Slider_ValueChanged);
		}

在代码中，因为滑块的值变化后，会触发ValueChanged事件，而该事件又会设置PageViewer的Scale属性，这样会形成循环触发事件，

所以代码先去掉了对于ValueChanged事件的关联，而设置完值后再重新关联事件。

 /// <summary>
        /// 触发放大缩小路由事件
        /// </summary>
        protected void RaiseZoomChanged()
        {  //定义路由事件参数实例
            ZoomRoutedEventArgs args = new ZoomRoutedEventArgs(_scale);
            args.RoutedEvent = ZoomChangedEvent;//指定路由事件代码
            RaiseEvent(args);//引发路由事件
        }

 路由事件的定义：

路由事件和 . NET事件的定义有一些区别。路由事件的定义是由公共的静态RoutedEvent成员加一个约定的Event后缀组成，

路由事件需要在.NET事件系统中进行注册。

然后路由事件也有一个和普通.NET事件一样的事件定义，或者是一个事件包装器，使得可以像使用普通事件那样使用路由事件。

/// <summary>
		/// 注册路由事件
		/// </summary>
		public static readonly RoutedEvent 
            ZoomChangedEvent = EventManager.RegisterRoutedEvent("ZoomChangedEvent",
																RoutingStrategy.Bubble,
																typeof(ZoomChangedEventHandler), typeof(PageViewer));

 

	/// <summary>
		/// 事件处理委托
		/// </summary>
		public delegate void ZoomChangedEventHandler(object sender, ZoomRoutedEventArgs e);
		/// <summary>
		/// 路由事件的普通属性定义
		/// </summary>
		public event ZoomChangedEventHandler ZoomChanged
		{
			add { AddHandler(ZoomChangedEvent, value); }
			remove { RemoveHandler(ZoomChangedEvent, value); }
		}

在代码中，定义了一个ZoomChangedEventHandler类型的委托，首先调用定义一个名为ZoomChangedEvent的RoutedEvent，通过调用

EventManager.RegisterRoutedEvent()方法向WPF的事件系统注册路由事件。

RoutingStrategy枚举用于指定路由策略，路由策略是指事件在触发后，事件如何在元素树中传递的方式，有如下3种可选：

Bubble：冒泡传递，事件首先在源元素上触发，然后从每一个元素上沿着树传递，直到根元素为止；

Tunneling： 逐道传递，事件首先在根元素上被触发，依次向源元素传递。

 ============================================================================================================================

 

 4、6 处理屏幕滚动

当按下PageDown或向下方向键时，会调用ManageScroolDown()方向进行滚动，相反会调用ManageScroolUp()处理向上滚动。

这两个方法实现了屏幕滚动和翻页的操作。

    //处理键盘事件
        private void PageContent_PreviewKeyUp(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.LeftShift)//如果用户控下左边的Shift键
            {   //显示放大镜工具
                Magnifier.Display(Visibility.Hidden);
				//释放页面事件铺获
				this.PageContent.ReleaseMouseCapture();
				//己处理该预览事件，下面的元素不再处理
				e.Handled = true;
                return;
            }
            //如果按下PageDown或向下方向键
            if (e.Key == Key.PageDown || e.Key == Key.Down)
            {
                ManageScroolDown();//处理向下滚动
                e.Handled = true;
				return;
            }
            //如果按下PageUp或向上方向键
            else if (e.Key == Key.PageUp || e.Key == Key.Up)
            {
                ManageScroolUp();//处理向上滚动，并触发事件
                e.Handled = true;
				return;
            }
        }

 

  //处理ScrollViewer向上滚动
        private void ManageScroolDown()
        {
            try
            {   //如果滚动条向上偏移量加上可视高度大于垂直大小
                if (this.PageContent.VerticalOffset + 
                    this.PageContent.ViewportHeight >= 
                    this.PageContent.ExtentHeight)
                {   //如果不用到页面底部
                    if (!WaitAtBottom)
                    {  //设置该属性的值
                        WaitAtBottom = true;
                        return;
                    }
                    else WaitAtBottom = false;
                    //触发页面变更事件
                    RaisePageChanged(1);
				}
            }
            catch (Exception err)
            {  //如果出现异常显示异常信息
                ExceptionManagement.Manage("PageViewer:ManageScroolDown", err);
            }
        }

实际上ManageScroolDown并没有处理滚动，而是设置了滚动的状态后，将滚动工作交给了PageChanged事件。

MainWindow.maml.cs的PageChanged事件处理中，将根据传入的PageRoutedEvnetArgs参数来进行实际的滚动操作。

代码如下：

 //处理滚动和页面变更
		private void SimplePageView_PageChanged
            (object sender, PageViewer.PageRoutedEventArgs e)
		{
			if (e.PageOffset == -1) //如果是向上跳转页面
			{
				if (_CurrentBook.GotoPreviousPage())//跳转到上一页面
				{   //当前页面将为上一页面
					this.SimplePageView.Source = _CurrentBook.GetCurrentPageImage();
                    //指定主页面的文件路径信息
					this.PageInfo.Content = _CurrentBook.CurrentPage.FilePath;
                    //滚动到上一页面的顶部
					this.SimplePageView.ScrollToBottom();
				}
			}
			else
				if (e.PageOffset == 1) //如果是要向下跳转页面
				{
					if (_CurrentBook.GotoNextPage())//跳到下一页
					{    //显示下一页面
						this.SimplePageView.Source = _CurrentBook.GetCurrentPageImage();
                        //指定下一页面的文件路径
						this.PageInfo.Content = _CurrentBook.CurrentPage.FilePath;
                        //滚动到页面顶部
						this.SimplePageView.ScrollToHome();
					}
				}
		}

 

在代码中，根据PageRoutedEventArgs传入是否翻页值，调用_CurrentBook的GotoPreviousPage或GotoNextPage来进行上下翻页，

并调用ScrollToBootom或ScrollToHome滚动到页面的底部或顶部。

ScrollViewer控件本身能处理上下方向键进行上下滚动的工作，但是不理解向上或向下翻页的行为。通过处理

PageContent_PreviewKeyUp事件，在到达屏幕顶部或底部时可以进行上下翻页，大大提升阅读体验。

 

 4、7  控制鼠标滚轮

两种行为：

（1） 在按下Ctrl+鼠标滚轮，会对图书页面进行放大或缩小

（2） 如果不按下Ctrl，将进行屏幕滚动的工作。

ScrollViewer本身可以处理鼠标滚轮的动作，但是不理解上下翻页的行为，

因此可以为其添加翻页功能。

  //处理鼠标滚轮事件
        private void PageContent_PreviewMouseWheel
            (object sender, MouseWheelEventArgs e)
        {
            //如果按下了键盘左边的Ctrl键
            if (Keyboard.IsKeyDown(Key.LeftCtrl))
            {   //更新屏幕内容，进行大小缩放
				UpdateContent(e.Delta > 0);
                e.Handled = true;
            }
            else
            {
                if (e.Delta > 0)//如果是向上滚动
                {
                    ManageScroolUp();//向上翻页
                }
                else
                {
                    ManageScroolDown();//向下翻页
                }
            }
        }

4、8 实现页面拖动效果

4、9 创建放大器用户控件