标签：控件 入门 -- 代码 对象 面向对象编程 使用 NET 应用

C# 面向对象编程入门指南（全）

原文：Beginning C# object-oriented programming

协议：CC BY-NC-SA 4.0

零、简介

作为一名. NET 培训师和首席程序员，我的经验是，大多数人在掌握 C# 语言的语法方面没有问题。困扰和挫败许多人的是面向对象编程方法和设计的更高层次的概念。更糟糕的是，大多数介绍性的编程书籍和培训课程都忽略了这些概念，或者更糟糕的是，根本没有涉及到它们。我希望这本书能填补这一空白。我写这本书的目的有两个。我的第一个目标是为您提供理解 C# 编程基础所需的信息。更重要的是，我的第二个目标是为您提供掌握面向对象编程方法和设计的高级概念所需的信息。

这本书提供了你需要的知识来构建一个面向对象的编程解决方案，旨在解决一个业务问题。当您阅读本书时，您将首先学习如何分析应用的业务需求。接下来，您将对解决方案设计中涉及的对象和关系进行建模。最后，您将使用 C# 实现该解决方案。在这个过程中，您将学习软件设计的基础知识、统一建模语言(UML)、面向对象编程、C# 和 .NET 框架。

因为这是一本介绍性的书，所以它是你学习它所呈现的主题的起点。因此，这本书不是为了让你成为面向对象编程和 UML 的专家；也不是对 C# 和 .NET 框架；也不是对 Visual Studio 的深入研究。精通这些领域中的任何一个都需要相当多的时间和努力。我希望通过阅读这本书，你在面向对象编程方面的第一次经历将会是愉快的和容易理解的——并且这些经历将会灌输进一步学习的愿望。

目标受众

本书的目标读者是初学 C# 的程序员，他们希望在掌握 C# 语言基础的同时，掌握面向对象编程的基础。从面向过程编程模型过渡到面向对象模型的程序员也将从本书中受益。另外，还有很多 Visual Basic (VB)程序员想过渡到 C#。在过渡到 C# 之前，您必须理解面向对象编程的基础。

因为“初学者”的经验水平可能会有很大的差异，所以我在附录 A 中包含了一本讨论一些基本编程概念以及如何用 C# 实现它们的入门书。如果你是编程新手，我建议你复习一下这些概念。

活动和软件要求

学习最重要的一个方面是做。不骑自行车就学不会骑自行车，不出代码就学不会编程。任何成功的培训计划都需要包括理论和实践两个部分。

我在本书中包含了这两个部分。我希望你会认真对待我在每一章中添加的活动，并彻底完成它们——甚至是反复完成。与一些学生认为这些活动是“打字练习”相反，在这些活动中，你有机会将理论具体化，并对概念进行真正的模拟。我也鼓励你在一项活动中边工作边玩耍。不要害怕修改一些代码，看看会发生什么。一些最好的学习经历发生在学生“超越界限”的时候

前面章节中的 UML 建模活动是为使用 UMLet 的人设计的。我选择这个程序是因为它是一个很好的学习绘图工具。它允许您创建 UML 图，而无需添加许多与高端 CASE 工具相关的高级特性。UMLet 是一个免费的开源工具，可以从www.umlet.com下载。您也可以使用 Visio 等其他工具来完成这些活动。然而，你不需要一个工具来完成这些活动；纸和铅笔就可以了。

一旦你开始编码，你将需要安装 C# 的 Visual Studio 2012。我鼓励您安装帮助文件，并在完成活动时充分利用它们。第十三章讲述了如何创建 Windows 应用商店应用，并要求在 Windows 8 操作系统上安装 Visual Studio。后面的章节要求安装了 Pubs 和 Northwind 数据库的 Microsoft SQL Server 2008 或更高版本。附录 C 包括下载和安装示例数据库的说明。你可以在www.msdn.microsoft.com找到 Visual Studio 和 SQL Server 的免费速成版和试用版，以及 Windows 8 的试用版。

一、面向对象编程概述

为了给你学习面向对象编程(OOP)和 C# 打下基础，本章将简要介绍面向对象编程的历史和面向对象编程语言的特点。您将看到为什么面向对象编程在工业级分布式软件系统的开发中变得如此重要。您还将研究 C# 是如何发展成为主流应用编程语言之一的。

阅读本章后，您将熟悉以下内容:

• 什么是面向对象编程
• 为什么面向对象编程在工业级应用的开发中变得如此重要
• 使编程语言面向对象的特征
• C# 的历史和演变

OOP 是什么？

面向对象编程是一种软件开发方法，在这种方法中，软件的结构基于对象之间的交互来完成任务。这种交互采取在对象之间来回传递消息的形式。作为对消息的响应，对象可以执行一个动作。

如果你看看你是如何在你周围的世界中完成任务的，你可以看到你在一个面向对象的世界中互动。例如，如果你想去商店，你可以与一个汽车对象进行交互。汽车对象由其他对象组成，这些对象相互交互以完成将您带到商店的任务。你把钥匙放在点火物体里，转动它。这反过来向启动器对象发送一条消息(通过电信号)，启动器对象与引擎对象交互以启动汽车。作为一名司机，你与系统的对象如何一起工作来启动汽车的逻辑是隔离的。您只需通过用钥匙执行点火对象的 start 方法来启动事件序列。然后，您等待成功或失败的响应(消息)。

类似地，软件程序的用户与完成任务所需的逻辑相隔离。例如，当您在文字处理器中打印页面时，您可以通过单击打印按钮来启动该操作。你被从需要发生的内部处理中隔离出来；你只需等待一个告诉你是否打印的回复。在软件程序中，按钮对象与打印机对象交互，打印机对象与实际打印机交互以完成打印页面的任务。

面向对象的历史

OOP 概念在 20 世纪 60 年代中期随着一种叫做 Simula 的编程语言出现，并在 20 世纪 70 年代随着 Smalltalk 的出现而进一步发展。尽管软件开发人员并没有完全接受 OOP 语言的这些早期进步，但是面向对象的方法继续发展。在 20 世纪 80 年代中期，人们对面向对象的方法又有了新的兴趣。具体来说，C++和 Eiffel 等 OOP 语言开始受到主流计算机程序员的欢迎。OOP 在 20 世纪 90 年代继续流行，最显著的是 Java 的出现和它吸引的大量追随者。在 2002 年，随着。微软引入了一种新的面向对象语言 C#(发音为 C-sharp ),并改进了他们广泛流行的现有语言 Visual Basic，使其现在真正面向对象。今天，OOP 语言继续蓬勃发展，是现代编程的中流砥柱。

为什么要用 OOP？

为什么 OOP 已经发展成为当今解决业务问题的广泛使用的范例？在 20 世纪 70 年代和 80 年代，面向过程的编程语言如 C、Pascal 和 Fortran 被广泛用于开发面向商业的软件系统。过程语言以线性方式组织程序，它们从上到下运行。换句话说，程序是一系列一个接一个运行的步骤。这种类型的编程对于由几百行代码组成的小程序来说很好，但是随着程序变大，它们变得难以管理和调试。

为了管理不断增长的程序规模，引入了结构化编程来将代码分解成可管理的称为函数或过程的片段。这是一个进步，但是随着程序执行更复杂的业务功能并与其他系统交互，结构化编程的以下缺点开始显现:

• 程序变得更难维护。
• 在不对系统的所有功能产生负面影响的情况下，很难改变现有的功能。
• 新程序基本上是从零开始构建的。因此，以前的投资回报很少。
• 编程不利于团队发展。程序员必须知道一个程序如何工作的每一个方面，不能把他们的努力孤立在系统的一个方面。
• 很难将业务模型转化为编程模型。
• 结构化编程在孤立的情况下工作得很好，但是不能很好地与其他系统集成。

除了这些缺点之外，计算系统的一些发展对结构化程序方法造成了进一步的压力，例如:

• 非程序员通过图形用户界面和他们的台式计算机的结合，要求并获得了对程序的直接访问。
• 用户需要一种更直观、更少结构化的方法来与程序交互。
• 计算机系统发展成一种分布式模型，其中业务逻辑、用户界面和后端数据库是松散耦合的，并通过 Internet 和 intranets 进行访问。

因此，许多商业软件开发人员转向了面向对象的方法和编程语言。这些好处包括如下:

• 从业务分析模型到软件实现模型的更直观的转变
• 更有效、更快速地维护和实施计划变更的能力
• 使用团队过程更有效地创建软件系统的能力，允许专家处理系统的各个部分
• 能够在其他程序中重用代码组件，并购买由第三方开发人员编写的组件，从而毫不费力地增加现有程序的功能
• 与松散耦合的分布式计算系统更好地集成
• 改进了与现代操作系统的集成
• 为用户创建更直观的图形用户界面的能力

面向对象的特点

在这一节中，你将研究一些所有面向对象语言共有的基本概念和术语。不要担心这些概念是如何在任何特定的编程语言中实现的；那是以后的事。我的目标是让你熟悉这些概念，并把它们与你的日常经验联系起来，这样当你以后看 OOP 设计和实现时，它们就更有意义了。

目标

正如我前面提到的，我们生活在一个面向对象的世界里。你是一件物品。你与其他物体互动。其实你就是一个物体，有你的身高，发色等数据。你也有你执行的方法或在你身上执行的方法，例如吃和走。

那么什么是对象？用面向对象的术语来说，对象是一个用来合并数据和处理数据的过程的结构。例如，如果您对跟踪与产品库存相关的数据感兴趣，您可以创建一个 product 对象，负责维护和使用与产品相关的数据。如果您想在应用中拥有打印功能，您可以使用一个打印机对象，该对象负责用于与打印机交互的数据和方法。

抽象

当您与世界上的对象交互时，您通常只关心它们属性的子集。如果没有这种提取或过滤物体无关属性的能力，你会发现很难处理轰炸你的大量信息并专注于手头的任务。

作为抽象的结果，当两个不同的人与同一个对象交互时，他们经常处理不同的属性子集。例如，当我开车时，我需要知道汽车的速度和方向。因为汽车使用自动变速器，所以我不需要知道发动机的每分钟转数，所以我过滤掉这些信息。另一方面，这些信息对于赛车手来说至关重要，他们不会过滤掉这些信息。

当在 OOP 应用中构造对象时，结合这个抽象概念是很重要的。这些对象只包括与应用上下文相关的信息。如果您正在构建一个运输应用，您将构建一个具有诸如尺寸和重量等属性的产品对象。该项目的颜色是无关的信息，将被忽略。另一方面，在构建订单输入应用时，颜色可能很重要，并且会作为产品对象的属性包含在内。

包装

OOP 的另一个重要特征是封装。封装是不允许对数据进行直接访问的过程；反而是隐藏的。如果您想要访问数据，您必须与负责数据的对象进行交互。在前面的库存示例中，如果您想要查看或更新产品信息，您必须处理产品对象。要读取数据，您需要向产品对象发送一条消息。然后，产品对象将读取该值并发回一条消息，告诉您该值是多少。产品对象定义了可以对产品数据执行的操作。如果您发送一条消息来修改数据，并且产品对象确定它是一个有效的请求，它将为您执行操作并发送一条消息返回结果。

你在日常生活中无时无刻不在体验着被封闭。想想人力资源部门。它们封装(隐藏)了员工的信息。他们决定如何使用和操作这些数据。任何对员工数据的请求或更新数据的请求都必须通过他们。再比如网络安全。任何对安全信息的请求或对安全策略的更改都必须通过网络安全管理员进行。对网络用户来说，安全数据是封装的。

通过封装数据，您可以使系统的数据更加安全可靠。您知道数据是如何被访问的，以及对数据执行了什么操作。这使得程序维护更加容易，也大大简化了调试过程。您还可以修改用于处理数据的方法，并且，如果您不改变请求方法的方式和发送回的响应类型，您就不必改变使用该方法的其他对象。想想当你在邮件中寄信的时候。你向邮局请求投递这封信。邮局是如何做到这一点的，你无从知晓。如果它更改了用于邮寄信件的路线，它不会影响您开始发送信件的方式。你不必知道邮局传递信件的内部程序。

多态

多态是两个不同的对象以他们自己独特的方式响应同一请求消息的能力。例如，我可以训练我的狗回应命令吠叫，训练我的鸟回应命令唧唧喳喳。另一方面，我可以训练它们既响应命令又说话。通过多态，我知道狗会用叫声回应，而鸟会用唧唧声回应。

这和 OOP 有什么关系？您可以创建对象，这些对象以自己独特的实现方式响应相同的消息。例如，您可以向在打印机上打印文本的打印机对象发送打印消息，也可以向将文本打印到计算机屏幕上的窗口的屏幕对象发送相同的消息。

多态的另一个好例子是英语中单词的使用。单词有许多不同的意思，但通过句子的上下文，你可以推断出哪个意思是想要的。你知道有人会说“饶了我吧！”不是让你打断他的腿！

在 OOP 中，你通过一个叫做重载的过程来实现这种类型的多态。您可以实现同名对象的不同方法。然后，该对象可以根据消息的上下文(换句话说，传递的参数的数量和类型)来判断要实现哪个方法。例如，您可以创建 inventory 对象的两种方法来查找产品的价格。这两种方法都将被命名为 getPrice。另一个对象可以调用这个方法并传递产品名称或产品 ID。inventory 对象可以通过请求传递的是字符串值还是整数值来判断运行哪个 getPrice 方法。

遗产

大多数现实生活中的对象都可以分为不同的层次。例如，您可以将所有狗归为具有某些共同特征的一类，如有四条腿和皮毛。他们的品种进一步将他们分为具有共同属性的亚组，如体型和神态。你也可以根据物体的功能对其进行分类。比如有商务车，也有休闲车。有卡车和客车。你根据汽车的品牌和型号来分类。为了理解这个世界，您需要使用对象层次和分类。

你在 OOP 中使用继承来根据共同的特征和功能对程序中的对象进行分类。这使得处理对象更加容易和直观。它还使编程更容易，因为它使您能够将一般特征组合到父对象中，并在子对象中继承这些特征。例如，您可以定义一个 employee 对象，该对象定义公司中雇员的所有一般特征。然后，您可以定义一个经理对象，该对象继承 employee 对象的特征，但也添加了贵公司经理特有的特征。由于继承关系，经理对象将自动反映雇员对象特征的任何变化。

聚合

聚合是指一个对象由一起工作的其他对象组成。例如，您的割草机对象是轮子对象、引擎对象、刀片对象等的组合。事实上，引擎对象是许多其他对象的组合。在我们周围的世界里有许多聚合的例子。在 OOP 中使用聚合的能力是一个强大的特性，它使您能够在程序中准确地建模和实现业务流程。

c# 的历史

在 20 世纪 80 年代，大多数运行在 Windows 操作系统上的应用都是用 C++编写的。尽管 C++是一种面向对象的语言，但可以说它是一种很难掌握的语言，程序员负责处理诸如内存管理和安全性等日常事务。这些内务处理任务很难实现，并且经常被忽略，这导致了充满 bug 的应用很难测试和维护。

在 20 世纪 90 年代，Java 编程语言开始流行。因为它是一种托管编程语言，所以它运行在一组统一的类库之上，这些类库负责低级编程任务，如类型安全检查、内存管理和销毁不需要的对象。这使得程序员可以专注于业务逻辑，而不必担心容易出错的内务代码。因此，程序更紧凑、更可靠、更易于调试。

看到 Java 的成功和互联网的日益普及，微软开发了自己的一套托管编程语言。微软想让开发基于 Windows 和基于 Web 的应用变得更容易。这些托管语言依赖于 .NET Framework 提供了许多功能来执行所有应用中所需的内务处理代码。在开发过程中 .NET 框架，类库是用一种叫做 C# 的新语言编写的。C# 的主要设计者和首席架构师是安德斯·海尔斯伯格。Hejlsberg 之前参与了 Turbo Pascal 和 Delphi 的设计。他利用以前的经验设计了一种 OOP 语言，这种语言建立在这些语言的成功之上，并改进了它们的缺点。Hejlsberg 还将类似于 C 的语法结合到语言中，以吸引 C++和 Java 开发人员。创建 .NET 框架和 C# 语言将现代概念，如面向对象、类型安全、垃圾收集和结构化异常处理直接引入平台。

自从发布 C# 以来，微软一直在寻求为该语言添加额外的功能和增强。例如，2.0 版本增加了对泛型的支持(泛型在第九章中有所涉及)，3.0 版本增加了 LINQ (更多信息请见第十章)以减少编程语言和用于检索和处理数据的数据库语言之间的阻抗不匹配。如今，C# 5.0 支持让并行和异步编程更易于开发人员实现(参见第八章)。随着微软对 C# 不断改进和发展的承诺，它将继续成为世界上使用最广泛的编程语言之一。

微软也致力于提供 .NET 开发人员拥有必要的工具，以获得高效和直观的编程体验。虽然您可以使用文本编辑器创建 C# 程序，但大多数专业程序员发现集成开发环境(IDE)在易用性和提高生产率方面非常有价值。微软在 Visual Studio (VS)中开发了一个出色的 IDE。集成到 VS 中的许多特性使得 .NET 框架更直观(这些特性在第五章中有所介绍)。随着 Visual Studio 2012 的最新发布，微软继续增强设计时开发体验。VS 2012 包含了一些新特性，比如对并行编程的更好的调试支持和改进的代码测试体验。当你读完这本书时，我想你会逐渐体会到 Visual Studio 和 C# 语言所提供的强大功能和高效率。

摘要

在这一章中，你已经了解了面向对象的程序设计和 C# 的简史。既然您已经了解了 OOP 语言的组成以及 OOP 语言对于企业级应用开发如此重要的原因，那么您的下一步就是熟悉 OOP 应用是如何设计的。

为了满足用户的需求，必须仔细规划和开发成功的应用。下一章是三章系列的第一章，旨在向您介绍设计面向对象应用时使用的一些技术。您将看到决定应用中需要包含哪些对象的过程，以及这些对象的哪些属性对该应用的功能很重要。

二、设计 OOP 解决方案：识别类结构

作为商业软件开发人员，你将参与的大多数软件项目都是团队工作。作为团队中的程序员，您将被要求将设计文档转换成实际的应用代码。此外，因为面向对象程序的设计是一个迭代过程，设计者依赖软件开发者的反馈来提炼和修改程序设计。随着您在开发面向对象软件系统方面获得经验，您甚至可能会被邀请参加设计会议，并对设计过程做出贡献。因此，作为软件开发人员，您应该熟悉各种设计文档的目的和结构，并对这些文档的开发方式有所了解。

本章向您介绍一些用于设计系统静态方面的常用文档。(你将在下一章了解系统的动态方面是如何建模的。)为了帮助您理解这些文档，本章包括一些基于有限案例研究的实践活动。你会在本书的大部分章节中找到与讨论主题相对应的类似活动。

阅读本章后，您将熟悉以下内容:

• 软件设计的目标
• 统一建模语言的基础
• 软件需求规格的目的
• 用例图如何建模系统将提供的服务
• 类图如何对需要开发的对象类建模

软件设计的目标

在开发现代企业级面向对象程序时，组织良好的系统设计方法是必不可少的。设计阶段是软件开发周期中最重要的阶段之一。您可以将许多与失败的软件项目相关的问题追溯到糟糕的前期设计以及系统开发人员和系统消费者之间不充分的沟通。不幸的是，许多程序员和项目经理不喜欢参与系统的设计。他们认为任何不花在生产代码上的时间都是无效的。

更糟糕的是，随着“互联网时代”的到来，消费者期望开发周期越来越短。因此，为了满足不切实际的时间表和项目范围，开发人员倾向于放弃或缩短开发的系统设计阶段。这对系统的成功起反作用。在设计过程中投入时间将实现以下目标:

• 提供一个机会来审查当前的业务流程，并修复任何发现的低效或缺陷
• 教育客户软件开发过程是如何发生的，并让他们作为合作伙伴参与到这个过程中
• 创建现实的项目范围和完成时间表
• 为确定软件测试需求提供基础
• 降低实施软件解决方案所需的成本和时间

软件设计的一个很好的类比是建造一个家的过程。没有建筑师提供的详细计划(蓝图),你不会想到建筑商会开始建造房子。你会期望建筑师在设计蓝图之前和你讨论房子的设计。建筑师的工作就是倾听你的要求，并把它们转化成建筑者可以用来建造房屋的平面图。一个好的架构师还会告诉你哪些特性对你的预算和预计的时间表是合理的。

理解统一建模语言

为了成功地设计面向对象的软件，您需要遵循一个经过验证的设计方法。如今，OOP 中使用的一种经过验证的设计方法是统一建模语言(UML)。UML 开发于 20 世纪 80 年代早期，作为对面向对象软件设计建模的标准、系统方法的需求的回应。该行业标准由对象管理小组(OMG)创建和管理。UML 已经随着软件行业的发展而成熟，当前版本 2.4.1 于 2011 年正式发布。

在设计过程中使用 UML 有很多好处。当正确实现时，UML 允许您在不同的细节层次上可视化软件系统。您可以与用户一起验证项目的需求和范围。它也可以作为测试系统的基础。UML 非常适合增量开发过程。UML 建模对于大型系统的并行开发也非常有益。使用该模型，每个团队都知道他们的部分如何适应系统，并可以传达可能影响其他团队的变化。

UML 由所提议的解决方案的一系列文本和图形模型组成。这些模型定义了系统范围、系统组件、用户与系统的交互，以及系统组件如何相互交互以实现系统功能。

UML 中使用的一些常见模型如下:

• 软件需求说明书 (SRS) : 对系统整体职责和范围的文字描述。
• 用例 : 从用户的角度对系统行为的文本/图形描述。用户可以是人类或其他系统。
• 类图 : 将用于构建系统的对象的可视化蓝图。
• 序列图 : 程序执行时对象交互序列的模型。重点放在交互的顺序以及它们如何随时间进行。
• 协作图 : 程序执行时，对象如何组织在一起工作的视图。重点放在对象之间的通信上。
• 活动图 : 流程或操作执行流程的可视化表示。

在这一章中，你将会看到 SRS 的开发，用例，以及类图。第三章涵盖了顺序图、协作图和活动图。

制定安全气囊系统

SRS 的目的是完成以下工作:

• 定义系统的功能需求。
• 确定系统的边界。
• 识别系统的用户。
• 描述系统和外部用户之间的交互。
• 在客户和程序团队之间建立一种描述系统的通用语言。
• 为用例建模提供基础。

要制作 SRS，您需要采访业务所有者和系统的最终用户。这些访谈的目标是清楚地记录所涉及的业务流程，并确定系统的范围。该过程的结果是一份详细说明系统功能要求的正式文件(SRS)。正式文档有助于确保客户和软件开发人员之间达成一致。随着开发的进行，SRS 还为解决任何关于感知系统范围的分歧提供了基础。

例如，假设一家小型通勤航空公司的所有者希望客户能够使用 Web 注册系统查看航班信息并预订机票。与业务经理和票务代理面谈后，软件设计师起草一份 SRS 文档，列出系统的功能需求。以下是其中的一些要求:

• 未注册的网络用户可以浏览网站查看航班信息，但他们不能预订航班。
• 想要预订航班的新客户必须填写登记表，提供他们的姓名、地址、公司名称、电话号码、传真号码和电子邮件地址。
• 客户分为公司客户和零售客户。
• 客户可以根据目的地和出发时间搜索航班。
• 客户可以在预订航班时注明航班号和所需座位数。
• 预订航班后，系统会通过电子邮件向客户发送确认信息。
• 当公司客户的员工预订航班时，他们会获得常旅客里程。
• 常旅客里程用来对未来的购买打折。
• 机票预订可提前一周取消，并可获得 80%的退款。
• 票务代理可以查看和更新航班信息。

在这个部分 SRS 文档中，您可以看到几个简洁的语句定义了系统范围。它们从系统用户的角度描述系统的功能，并确定将使用它的外部实体。需要注意的是，SRS 不包含对系统技术要求的参考。

一旦 SRS 被开发出来，它所包含的功能需求就被转化为一系列的用例图。

引入用例

用例描述了外部实体将如何使用系统。这些外部实体可以是人或者其他系统(在 UML 术语中称为参与者)。描述强调用户对系统的看法以及用户和系统之间的交互。用例有助于进一步定义系统范围和边界。它们通常以图表的形式，伴随着对正在发生的交互的文本描述。图 2-1 显示了一个通用图，它由两个参与者组成，用简笔画表示，用矩形表示系统，用椭圆表示系统边界内的用例。

图 2-1 。有两个参与者和三个用例的通用用例图

用例是根据 SRS 文档开发的。参与者是与系统交互的任何外部实体。参与者可以是一个人类用户(例如，一个租赁代理)，另一个软件系统(例如，一个软件计费系统)，或者一个接口设备(例如，一个温度探测器)。参与者和系统之间发生的每个交互都被建模为一个用例。

图 2-2 中显示的示例用例是为上一节中介绍的机票预订应用开发的。它显示了需求“客户可以根据目的地和出发时间搜索航班”的用例图。

图 2-2 。查看航班信息用例

除了用例的图形化描述，许多设计人员和软件开发人员发现提供用例的文本描述很有帮助。文字描述应该简洁明了，集中在正在发生的事情上，而不是它是如何发生的。有时，与用例相关的任何先决条件或后置条件也被识别。下文进一步描述了图 2-2 中所示的用例图。

• 描述:顾客查看航班信息页面。客户输入航班搜索信息。提交搜索请求后，客户查看符合搜索条件的航班列表。
• 前提条件:无。
• 后置条件:客户有机会登录并进入机票预订页面。

再举一个例子，看看图 2-3 中显示的预留座位用例。

图 2-3 。预订座位用例图

下文进一步描述了图 2-3 中所示的用例图。

• 描述:顾客输入航班号，并指出所要求的座位。客户提交请求后，会显示一些确认信息。
• 前提条件:客户已经查询了航班信息。客户已经登录并正在查看航班预订屏幕。
• 后置条件:向客户发送一封确认电子邮件，概述航班详情和取消政策。

正如你从图 2-3 中看到的，在用例之间可以存在某些关系。预订座位用例包括查看航班信息用例。这种关系非常有用，因为您可以独立于预订航班用例使用查看航班信息用例。这叫包容。然而，您不能将预订座位用例与查看航班信息用例分开使用。这是将影响您如何对解决方案建模的重要信息。

用例相互关联的另一种方式是通过扩展。你可能有一个通用用例，它是其他用例的基础。其他用例扩展了基本用例。例如，您可能有一个注册客户用例，它描述了注册客户的核心过程。然后，您可以开发注册公司客户和注册零售客户用例，扩展基本用例。扩展和包含之间的区别在于，在扩展中，被扩展的基本用例不会单独使用。图 2-4 展示了你如何在用例图中建模。

图 2-4 。扩展用例

开发用例时的一个常见错误是包含由系统本身发起的动作。用例的重点是外部实体和系统之间的交互。另一个常见的错误是包含系统技术需求的描述。请记住，用例并不关注系统将如何执行功能，而是关注从用户的角度来看，什么功能需要被整合到系统中。

在您开发了系统的用例之后，您可以开始识别将执行系统功能需求的内部系统对象。您可以使用类图来实现这一点。

活动 2-1。创建用例图

完成本活动后，您应该熟悉以下内容:

• 如何生成用例图来定义系统的范围
• 如何使用 UML 建模工具创建并记录用例图

检查安全气囊

你所属的软件用户组决定集中资源，创建一个借阅图书馆。借出的物品包括书籍、电影和电子游戏。您的任务是开发一个应用，该应用将跟踪借出物品的库存以及向小组成员借出物品的情况。在与小组成员和官员面谈后，您制定了一份 SRS 文件，其中包括以下功能要求:

• 只有用户组的成员才能借阅物品。
• 书可以借四周。
• 电影和游戏可以借一个星期。
• 如果没有人在等着借阅，可以续借。
• 会员一次最多只能借四件物品。
• 当项目过期时，会通过电子邮件向成员发送提醒。
• 过期的项目要罚款。
• 有未偿还的过期项目或罚款的成员不能借新项目。
• 秘书负责维护项目库存和采购项目以添加到库存中。
• 已经任命了一名图书管理员来跟踪借阅情况并发送过期通知。
• 图书管理员还负责收集罚款和更新罚款信息。

接下来的步骤是分析 SRS 以识别参与者和用例。

1. 通过检查 SRS 文档，确定以下哪些是与系统交互的主要参与者:
   • A.成员
   • B.图书管理员
   • C.书
   • D.出纳员
   • E.库存
   • F.电子邮件
   • G.秘书
2. 一旦您确定了主要参与者，您就需要确定参与者的用例。确定与以下用例相关的参与者:
   • A.请求项目
   • B.目录项目
   • C.借出项目
   • D.加工精细

活动 2-1 答案见本章末尾。

创建用例图

尽管手工或在白板上创建 UML 图是可能的，但大多数程序员最终会求助于图表工具或计算机辅助软件工程(CASE)工具。 CASE 工具帮助您构建专业质量的图表，并使团队成员能够轻松地共享和扩充图表。市场上有许多 CASE 工具，包括 Microsoft Visio。在选择 CASE 工具之前，您应该彻底评估它是否满足您的需求，是否足够灵活。许多与高端 CASE 工具相关的高级特性很难使用，所以你花更多的时间去弄清楚 CASE 工具是如何工作的，而不是记录你的设计。

一个很好的学习绘图工具是 UMLet。UML let 使您能够创建 UML 图，而无需添加许多与高端 CASE 工具相关的高级特性。最棒的是，UMLet 是一个免费的开源工具，可以从www.umlet.com下载。

注意这些活动使用的是 UMLet 11.5.1 单机版。这也需要在www.java.com可用的 Java 1.6。

在下载并安装了 UMLet 之后，您可以完成以下步骤(如果您不想使用工具，您可以手工创建用例图):

1. 双击 UMLet.jar 文件启动 UMLet。您将看到三个窗口。主窗口是设计图面，右上角的窗口包含 UML 对象模板，右下角的窗口是您更改或添加对象属性的地方。

2. Locate the actor template in the upper right window (see Figure 2-5). Double click the actor template. An actor will appear in the upper left corner of the design surface.

   

   图 2-5 。定位演员模板

3. 如果尚未选择，请在设计图面上选择参与者形状。在右下窗口中，将执行元形状的名称更改为 Member。

4. 重复添加秘书和图书管理员执行元的过程。

5. 从“模板”窗口中，双击“用例 1”形状，将其添加到设计图面。将用例的名称更改为 Request Item。

6. 对另外两个用例重复步骤 5。包括当秘书向图书馆目录数据库添加新项目时将发生的目录项目用例。添加将在图书管理员处理项目请求时发生的借出项目用例。

7. From the Template window, double click the Empty Package shape and change the name to Library Loan System. Right click on the shape in the design surface and change the background color to white. Move the use case shapes inside the Library Loan System shape (see Figure 2-6).

   

   图 2-6 。将用例放入系统边界

8. From the Template window, double click on the Communications Link shape. It is the line with no arrow heads (see Figure 2-7). On the design surface, attach one end to the Member shape and the other end to the Request Item shape.

   

   图 2-7 。定位通信链路形状

9. 重复步骤 8 两次，在“图书管理员”和“出借”项目形状之间创建一个“通信链接”形状，并在“秘书”和“目录项目”形状之间创建一个“通信链接”形状。

10. 在模板窗口中，双击扩展关系箭头。将扩展箭头的尾端连接到借出项目用例，并将箭头的头部连接到请求项目用例。

11. Your completed diagram should be similar to the one shown in Figure 2-8. Save the file as UMLAct2_1 and exit UMLet.

![9781430249351_Fig02-08.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig02-08.jpg)

图 2-8 。完整的用例图

理解类图

类和对象的概念是面向对象的基础。对象是用于合并数据和处理数据的过程的结构。这些对象实现了面向对象程序的功能。把一个类想象成一个对象的蓝图，把一个对象想象成一个类的实例。类定义了基于类类型的对象将包含的结构和方法。

设计者从 SRS 和用例图中识别出他们需要开发的类的潜在列表。识别类的一种方法是查看 SRS 文档中的名词短语和用例描述。如果您查看到目前为止为机票预订应用开发的文档，您可以开始确定组成系统的类。例如，您可以开发一个处理客户数据的Customer类和一个处理航班数据的Flight类。

一个类负责管理数据。在定义类结构时，你必须确定类负责维护什么数据。类属性定义了这些信息。例如，Flight类将具有标识航班号、出发时间和日期、飞行持续时间、目的地、容量和可用座位的属性。类结构还必须定义将对数据执行的任何操作。Flight类负责的操作的一个例子是当座位被预订时更新可用的座位。

类图可以帮助您可视化类的属性和操作。 图 2-9 是航班预订系统示例中使用的Flight类的类图示例。分成三部分的矩形代表该类。矩形的上半部分显示了类的名称，中间部分列出了类的属性，下半部分列出了类执行的操作。

图 2-9 。飞行等级图

建模对象关系

在面向对象程序设计中，当程序执行时，各种对象协同工作来完成编程任务。例如，在机票预订应用中，为了预订航班座位，一个Reservation对象必须与Flight对象进行交互。两个对象之间存在关系，这种关系必须在程序的类结构中建模。组成程序的类之间的关系在类图中建模。分析 SRS 中的动词短语通常会揭示这些关系(这将在第三章的中详细讨论)。接下来的部分研究了类之间可能出现的一些常见关系，以及类图如何表示它们。

联合

当一个类引用或使用另一个类时，这些类就形成了一个关联。在两个类之间画一条线来表示关联，并添加一个标签来表示关联的名称。例如，在机票预订应用中，一个座位与一个航班相关联，如图图 2-10 所示。

图 2-10 。类别关联

有时一个类的单个实例与另一个类的多个实例相关联。这在连接两个类的线上有所表示。例如，当客户进行预订时，Customer类和Reservation类之间存在关联。一个Customer类的实例可能与多个Reservation类的实例相关联。放置在Reservation类附近的 n 表示这种多重性，如图图 2-11 所示。

图 2-11 。在类图中指示多重性

还可能存在一种情况，其中一个类的实例可能与同一类的多个实例相关联。例如，Pilot类的一个实例代表机长，而Pilot类的另一个实例代表副驾驶。飞行员管理副驾驶。这种场景被称为自关联，通过绘制从类到自身的关联线来建模，如图图 2-12 所示。

图 2-12 。一个自我联想的班级

遗产

当多个类共享一些相同的操作和属性时，基类可以封装共性。然后子类从基类继承。这在类图中用一条实线表示，该实线带有一个指向基类的开放箭头。例如，CorporateCustomer类和RetailCustomer类可以从基础Customer类中继承公共属性和操作，如图图 2-13 所示。

图 2-13 。记录继承

聚合

当一个类由其他类组合而成时，它们被归类为一个集合。这用连接分层结构中的类的实线来表示。在图中的类旁边的线上放置一个菱形表示层次结构的顶层。例如，一个为飞机维修部门设计的跟踪飞机零件的库存应用可以包含一个由各种零件类组成的Plane类，如图图 2-14 所示。

图 2-14 。描绘聚合

关联类

随着程序的类和关联的发展，可能会出现这样的情况，一个属性不能被分配给任何一个类，而是类之间关联的结果。例如，前面提到的零件库存应用可能有一个Part类和一个Supplier类。因为一个零件可以有多个供应商，并且供应商供应多个零件，那么价格属性应该位于哪里呢？它不适合作为任何一个类的属性，也不应该在两个类中重复。解决方案是开发一个关联类，它管理作为关联产品的数据。在这种情况下，你可以开发一个PartPrice类。关联和关联类之间用虚线建模，如图图 2-15 所示。

图 2-15 。联想类

图 2-16 显示了机票预订应用的演化类图。它包括已经为系统确定的类、属性和关系。与这些类相关的操作将在第三章中展开。

图 2-16 。机票预订类图

活动 2-2。创建类图

完成本活动后，您应该熟悉以下内容:

• 如何通过检查用例以及系统范围文档来确定需要构建的类
• 如何使用 UML 建模工具创建类图

识别类别和属性

检查为用户组库应用的用例开发的以下场景:

查看可用借出项目列表后，成员请求借出一个项目。图书管理员输入会员号，并检索有关未偿还贷款和任何未付罚款的信息。如果成员的未偿还贷款少于四笔，并且没有任何未偿还的罚款，则处理贷款。图书管理员检索关于借出项目的信息，以确定它当前是否被借出。如果项目可用，它将被签出给成员。

1. 通过识别用例场景中的名词和名词短语，您可以了解为了执行任务，您必须在系统中包含什么类。以下哪一项将成为系统的良好候选类别？
   • A.Member
   • B.Item
   • C.Librarian
   • D.Number
   • E.Fine
   • F.Checkout
   • G.Loan
2. 此时，您可以开始识别与正在开发的类相关联的属性。将开发一个Loan类来封装与借出项目相关的数据。下面哪个可能是Loan类的属性？
   • A.MemberNumber
   • B.MemberPhone
   • C.ItemNumber
   • D.ReturnDate
   • E.ItemCost
   • F.ItemType

活动 2-2 答案见本章末尾。

创建类图

要使用 UML Modeler 创建一个类图，请遵循以下步骤(您也可以手工创建):

1. 启动 UMLet。您将看到三个窗口。主窗口是设计图面，右上角的窗口包含 UML 对象模板，右下角的窗口是您更改或添加对象属性的地方。

2. Locate the SimpleClass template in the upper right window (see Figure 2-17). Double click the SimpleClass template. A SimpleClass will appear in the upper left corner of the design surface.

   

   图 2-17 。添加类形状

3. 在右下方的属性窗口中，将类名更改为Member。

4. 对Loan、Item、Book和Movie级重复该程序。

5. Locate the association template in the upper right window (see Figure 2-18). Double click the association template. An association will appear in the upper left corner of the design surface.

   

   图 2-18 。添加关联形状

6. Attach the left end of the association shape to the Member class and the right end to the Loan class shape. Select the association shape and update the properties in the properties window so that they match Figure 2-19.

   

   图 2-19 。更新关联属性

7. 重复步骤 5 和 6，在Loan类和Item类之间创建一个“包含一个”关联形状。这应该是一对一的关联。

8. Locate the generalization arrow template in the upper right window (see Figure 2-20). Double click the generalization shape. A generalization shape will appear in the upper left corner of the design surface.

   

   图 2-20 。添加一个概括箭头

9. Attach the tail end of the generalization arrow to the Book class and the head end to the Item class shape. Select the generalization arrow and update the properties in the properties widow so that they match Figure 2-21.

   

   图 2-21 。更新综合属性

10. 重复第 8 步和第 9 步，显示Movie类继承自Item类。

11. Click on the Member class in the design window. In the properties window, add the memberNumber, firstName, lastName, and eMail attributes as shown in Figure 2-22.

![9781430249351_Fig02-22.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig02-22.jpg)

图 2-22 。添加类属性

12. Your completed diagram should be similar to Figure 2-23. Save the file as UMLAct2_2.

![9781430249351_Fig02-23.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig02-23.jpg)

图 2-23 。完成的类图

摘要

在这一章中，你已经了解了面向对象设计过程和 UML 的目标。您学习了一些使用 UML 生成的设计文档和图表。这些包括 SRS，它定义了系统的范围；用例图，它定义了系统边界，并确定了将使用该系统的外部实体；和类图，它们对将要开发来实现系统的类的结构进行建模。

您看到了如何对应用的类结构进行建模，包括识别必要的类，识别这些类的属性，以及建立这些类之间所需的结构关系。在第三章中，你将继续学习面向对象设计。特别是，您将看到应用中的对象如何协作来实现应用的功能。

活动答案

活动 2–1 答案

1. 演员是会员、图书管理员和秘书。
2. A.会员，b 秘书，c 图书管理员，d 图书管理员。请求项用例与成员一起使用，目录项用例与秘书一起使用，借出项用例与图书管理员一起使用，流程精细用例与图书管理员一起使用。

活动 2–2 答案

1. a、B、C、E、g，候选班有Member、Item、Librarian、Fine、Loan。
2. 与Loan类相关的属性有MemberNumber、ItemNumber和ReturnDate。

三、设计 OOP 解决方案：建模对象交互

前一章关注于 OOP 解决方案的静态(组织)方面的建模。它介绍并讨论了 UML 的方法论。它还研究了用例图和类图的目的和结构。这一章继续讨论 UML 建模技术，并重点关注 OOP 解决方案的动态(行为)方面的建模。本章的重点是系统中的对象必须如何相互作用，以及必须发生什么活动来实现解决方案。这是建模过程的一个重要方面。这些模型将作为对构成软件应用的类的各种方法(在第二章中确定)进行编码的基础。

阅读本章后，您应该熟悉以下内容:

• 场景的目的以及它们如何扩展用例模型
• 序列图如何对系统中对象的时间相关交互进行建模
• 活动图如何映射应用处理期间的活动流
• 图形用户界面设计的重要性以及它如何适应面向对象的设计过程

了解场景

场景帮助确定系统的对象(类实例)之间将要发生的动态交互。场景是对实现用例所记录的功能所需的内部处理的文本描述。记住用例从系统外部用户的角度描述系统的功能。一个场景详述了用例的执行。换句话说，它的目的是描述组成系统的对象必须在内部执行的步骤。

图 3-1 显示了一个视频租赁应用的流程电影租赁用例 。以下文本描述了使用案例:

• 前提条件:客户向租赁人员请求租赁一部电影。该客户是视频俱乐部的会员，并向租赁店员提供了她的会员卡和个人身份号码(p in)。验证客户的会员资格。显示客户信息，并验证客户的帐户信誉良好。
• 描述:电影确认有货。记录租赁信息，并通知客户到期日期。
• 岗位条件:无。

图 3-1 。处理电影租赁用例

以下场景描述了流程电影租赁用例的内部处理:

• 电影经核实有现货。
• 库存中的可用份数减少。
• 到期日已确定。
• 租赁信息被记录。这些信息包括电影标题、拷贝数、当前日期和到期日期。
• 客户被告知租赁信息。

这个场景描述了用例的最佳可能执行。因为异常可能发生，一个用例可以产生多个场景。例如，为流程电影租赁用例创建的另一个场景可以描述当电影没有库存时会发生什么。

在您为一个用例规划出各种场景之后，您可以创建交互图来确定哪些类的对象将参与执行场景的功能。交互图还揭示了这些对象类需要什么操作。交互图有两种风格:序列图和协作图。

序列图介绍

一个序列图模拟了当系统运行时，对象类如何随着时间的推移而相互作用。序列图是正在发生的交互的可视化二维模型，并且基于一个场景。图 3-2 显示了一个通用顺序图。

图 3-2 。通用序列图

如图 3-2 所示，从一个对象到另一个对象的消息流是水平的。交互发生的时间流程是垂直描述的，从顶部开始向下进行。根据调用顺序，对象从左到右并排放置。虚线从它们中的每一个向下延伸。这条虚线代表对象的生命线。生命线上的矩形代表对象的激活。矩形的高度表示对象激活的持续时间。

在 OOP 中，对象通过相互传递消息来进行交互。从发起对象开始到接收对象结束的箭头描述了交互。拉回到发起对象的虚线箭头表示返回消息。序列图中描述的消息将形成系统的类的方法的基础。图 3-3 显示了上一节中介绍的流程电影租赁场景的示例序列图。在这一点上，该图只模拟了电影有库存的情况。

图 3-3 。流程电影租赁顺序图

当你分析序列图时，你会对执行程序处理所涉及的对象类别有所了解；您还将了解需要创建哪些方法并附加到这些类。您还应该在类图中对序列图中描述的类和方法进行建模。这些设计文件必须不断交叉引用，并在必要时进行修订。

图 3-3 中的序列图揭示了执行流程电影租赁场景将涉及四个对象。

• Customer对象是Customer类的一个实例，负责封装和维护关于客户的信息。
• RentalClerk对象是RentalClerk类的一个实例，负责管理租借电影所涉及的处理。
• RentalItem对象是RentalItem类的一个实例，负责封装和维护与出租视频相关的信息。
• Rental对象是Rental类的一个实例，负责封装和维护与当前租用的视频相关的信息。

消息类型

通过分析序列图，您可以确定哪些消息必须在处理中涉及的对象之间传递。在 OOP 中，消息是同步或异步传递的。

当消息以同步方式传递时，发送对象会暂停处理并等待响应，然后再继续。序列图中用闭合箭头画的线代表同步消息传递。

当对象发送异步消息时，该对象继续处理，并且不期望接收对象立即响应。序列图中用空心箭头画的线代表异步消息传递。虚线箭头通常表示响应消息。这些线如图 3-4 所示。

图 3-4 。不同类型的消息

通过研究图 3-3 中所示的流程电影租赁场景的序列图，您可以看到必须传递的消息类型。例如，RentalClerk对象发起与RentalItem对象的同步消息，请求关于电影拷贝是否有货的信息。然后，RentalItem对象向RentalClerk对象发回一个响应，表明有一份拷贝。这需要同步，因为RentalClerk正在等待响应来处理请求。异步消息的一个例子是，当电影返回时，有人注册了电子邮件提醒。在这种情况下，将发送一条消息来启动电子邮件，但不需要响应。

递归消息

在 OOP 中，一个对象拥有一个调用它自己的另一个对象实例的操作并不罕见。这被称为递归。在序列图中，返回调用对象的消息箭头代表递归。箭头的末端指向一个更小的激活矩形，代表在原始激活矩形上绘制的第二个对象激活(见图 3-5 )。例如，Account对象计算逾期付款的复利。为了计算几个复利周期的利息，它需要调用自己几次。

图 3-5 。绘制递归消息的图表

消息迭代

有时，会重复消息调用，直到满足某个条件。例如，在合计租金时，会重复调用和Add方法，直到向客户收取的所有租金都被加到总数中。在编程术语中，这就是迭代。在迭代消息周围画出的矩形代表序列图中的一次迭代。迭代的绑定条件显示在矩形的左上角。图 3-6 显示了序列图中描述的一个迭代的例子。

图 3-6 。描绘了一个迭代的信息

消息约束

对象之间的消息调用可能有附加的条件约束。例如，顾客必须有良好的信誉才能被允许租借电影。将约束条件放在序列中的方括号([])内。仅当条件评估为真时，才会发送消息(参见图 3-7 )。

图 3-7 。识别条件约束

消息分支

当条件约束被绑定到消息调用时，您经常会遇到分支情况，在这种情况下，根据条件的不同，可能会调用不同的消息。图 3-8 表示请求电影租赁时的条件约束。如果租赁项目的状态是“库存中”，则向Rental对象发送一条消息来创建租赁。如果租赁物品的状态是“缺货”，那么会向Reservation对象发送一条消息来创建预订。围绕信息画出的矩形(图 3-8 中标为 alt)显示了根据条件可能出现的替代路径。

图 3-8 。序列图中的分支消息

活动 3-1。创建序列图

完成本活动后，您应该熟悉以下内容:

• 生成序列图来模拟对象交互
• 使用 UML 建模工具创建序列图
• 向类图中添加方法

检查场景

以下场景是为活动 2-1 中介绍的用户组库应用中的一个用例创建的。它描述了当成员从图书馆借书时所涉及的处理过程。

当一名会员提出借阅请求时，图书管理员会检查该会员的记录，以确保不存在未支付的罚款。一旦成员通过了这些检查，就会检查该物品是否可用。一旦确认了物品的可用性，就会创建一个记录物品号、会员号、结帐日期和归还日期的借出。

1. 通过检查场景中的名词短语，您可以确定哪些对象将参与执行处理。被识别的对象也应该有一个在类图中描述的相应的类，这个类图已经被创建了。从描述的场景中，找出五个将执行处理的对象。
2. 在对象被识别并与类图交叉引用之后，下一步是识别这些对象之间必须发生的消息传递以执行任务。你可以看看场景中的动词短语来帮助识别这些信息。例如，“请求借阅项目”短语表示成员对象和图书管理员对象之间的消息交互。场景中描述的其他交互是什么？

活动 3-1 答案见本章末尾。

创建顺序图

按照以下步骤，使用 UMLet 创建一个序列图:

1. Start UMLet. Locate the drop-down list at the top of the template window. Change the template type to Sequence (see Figure 3-9).

   

   图 3-9 。更改模板形状类型

2. 双击模板窗口中的实例形状。一个实例形状将出现在设计图面的左上角。在“属性”窗口中，将形状的名称更改为Member。

3. From the shapes window, locate the lifeline and activation shapes (see Figure 3-10) and add them to the Member instance, as shown in Figure 3-11.

   

   图 3-10 。定位生命线和激活形状

   

   图 3-11 。向序列图添加形状

4. Repeat steps 2 and 3 to add a Librarian, LoanHistory, Item, and Loan object to the diagram. Lay them out from left to right as shown in Figure 3-12.

   

   图 3-12 。序列图中的对象布局

5. 在形状模板窗口中，双击序列消息箭头形状。将箭头的尾端连接到Member对象的生命线，并将箭头的头部连接到Librarian对象的生命线。在“属性”窗口中，将消息的名称更改为“请求项”

6. To create a return arrow, double-click on the solid arrow with the open arrow head in the shapes template window. In the properties window, change the first line to lt=.< This should change the arrow from solid to dash. Attach the tail end to the Librarian object and the head end to the Member object. Change the name to “Return Loan Info.” Your diagram should look similar to Figure 3-13.

   

   图 3-13 。序列图中的消息布局

7. 重复步骤 5 和 6，创建一条从Librarian对象到LoanHistory对象的消息。将调用消息(实线)命名为“检查历史”将返回消息(虚线)命名为“返回历史”

8. 创建一条从Librarian对象到Item对象的消息。将呼叫消息命名为“检查可用性”将返回消息命名为“返回可用性信息”

9. 创建一条从Librarian对象到Item对象的消息。将调用消息命名为“更新状态”将返回消息命名为“返回更新确认”

10. 创建一条从Librarian对象到Loan对象的消息。将调用消息命名为“创建贷款”将返回消息命名为“归还贷款确认”

11. Rearrange the shapes so that your diagram looks similar to Figure 3-14. Save the diagram as UML_Act3_1.

![9781430249351_Fig03-14.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig03-14.jpg)

图 3-14 。完整的序列图

向类图添加方法

在您开发了序列图之后，您开始了解必须包含在应用的各个类中的方法。通过从发起对象(客户机)到接收对象(服务器)的方法调用，可以实现序列图中描述的消息交互。被调用的方法是在服务器对象被实例化为的类中定义的。例如，序列图中的“检查可用性”消息表明 Item 类需要一个方法来处理这个消息调用。

按照以下步骤添加方法:

1. 在 UMLet 中，选择 File New 来创建一个新的图表。找到模板窗口顶部的下拉列表。将模板类型更改为 Class。

2. 双击简单的类形状模板。在设计窗口中选择形状。

3. 在“属性”窗口中，将类名更改为Item。在“属性”窗口中的名称下，输入两个破折号。这将在类形状中创建新的部分。这一部分是您输入类属性的地方。

4. 在“属性”窗口中，将ItemNumber属性添加到该类中，后跟两个破折号。这将在类形状中创建第三个部分，用于添加该类的方法。

5. Add a CheckAvailability and an UpdateStatus method to the class as shown in Figure 3-15.

   

   图 3-15 。向类中添加方法

6. 将图表另存为 UML_Act3_1b。

理解活动图

活动图说明了在操作或流程中需要发生的活动的流程。您可以构建活动图来查看不同关注级别的工作流。

• 高度的、系统级的关注将每个用例表示为一个活动，并在不同的用例之间绘制工作流程图。
• 中级焦点图示了特定用例中发生的工作流。
• 低层次的焦点图示了在系统的一个类的特定操作中发生的工作流。

活动图由实心圆表示的流程起点和表示从一个活动到下一个活动的流程或转换的转换箭头组成。圆角矩形代表活动，牛眼圆形代表流程的终点。例如，图 3-16 显示了一个通用的活动图，它代表了一个从活动 A 开始，进行到活动 B，然后结束的过程。

图 3-16 。通用活动图

决策点和警戒条件

通常，一个活动会有条件地跟随另一个活动。例如，为了租借视频，PIN 验证成员资格。活动图通过流程线旁边的括号(见图 3-17 )用警戒条件(必须满足的条件)表示决策点的制约性。

图 3-17 。指示决策点和保护条件

并行处理

在某些情况下，两个或多个活动可以并行运行，而不是顺序运行。垂直于过渡箭头绘制的粗实线表示路径的分割。拆分后，第二条粗实线代表合并。图 3-18 显示了电影退货处理的活动图。增量库存和移除租赁活动的发生顺序无关紧要。图中的并行路径代表了这种并行处理。

图 3-18 。活动图中描述的并行处理

活动所有权

活动图的目的是在程序进行的过程中，对活动之间的控制流进行建模。迄今为止显示的图表并没有指出哪些对象负责这些活动。为了表示活动的对象所有权，您将活动图分割成一系列垂直分区(也称为泳道)。分区顶部的对象角色负责该分区中的活动。图 3-19 显示了处理电影租赁的活动图，包括泳道。

图 3-19 。活动图中的泳道

活动 3-2。创建活动图

完成本活动后，您应该熟悉以下内容:

• 使用活动图来模拟程序完成活动时的控制流
• 使用 UML 建模工具创建活动类图

识别对象和活动

检查为用户组库应用的用例开发的以下场景:

查看可用借出项目列表后，成员请求借出一个项目。图书管理员输入会员号，并检索有关未偿还贷款和任何未付罚款的信息。如果成员的未偿还贷款少于四笔，并且没有任何未偿还的罚款，则处理贷款。图书管理员检索关于借出项目的信息，以确定它当前是否被借出。如果项目可用，它将被签出给成员。

通过识别用例场景中的名词和名词短语，您可以了解在执行活动时什么对象将执行任务。请记住，这些对象是类图中标识的类的实例。活动的开展将涉及到以下对象:Member、Librarian、LoanHistory、Item、Loan。

动词短语有助于识别对象执行的活动。这些活动应该对应于系统中类的方法。将下列活动与适当的物体配对:

• A.请求电影
• B.过程租赁
• C.检查可用性
• D.检查会员的贷款状况
• E.更新项目状态
• F.计算到期日
• G.记录租赁信息
• H.确认租赁

活动 3-2 答案见本章末尾。

创建活动图

按照以下步骤，使用 UMLet: 创建一个活动图

1. 启动 UMLet。找到模板窗口顶部的下拉列表。将模板类型更改为活动。

2. 双击模板窗口中的系统框形状。系统框形状将出现在设计图面的左上角。在“属性”窗口中，将该形状的名称更改为 Member，以表示成员分区。

3. Repeat step 2 to add a partition for the Librarian, LoanHistory, Item, and Loan objects. Align the partitions from left to right as in Figure 3-20.

   

   图 3-20 。创建活动图分区

4. 从“形状”窗口中，双击“初始状态”形状，并将其添加到成员分区中。在成员分区的初始状态下，添加一个状态形状。将状态重命名为“请求项目”添加从初始状态到请求项目操作状态的转换形状(箭头)。

5. 在 Librarian 分区下，添加一个“处理借出”状态和一个从请求项目状态到处理借出状态的转换形状。

6. 在 LoanHistory 分区下，添加“检查成员状态”操作状态和从“处理贷款”操作到“检查成员状态”操作状态的转换形状。

7. From the Shapes window, double-click the Conditional Branch shape (diamond) and add it to the LoanHistory partition below the Check Member Status action state. Add a Transition shape from the Check Member Status state to the Conditional Branch. From the Conditional Branch, add a Transition shape to a Deny Loan state under the Librarian partition. Add a label to the Transition shape with a condition of “fail.” Also add a Transition shape to a Check Item Status action state under the Item partition with a label condition of “pass.” Your diagram should be similar to Figure 3-21.

   

   图 3-21 。添加分支条件

8. 重复步骤 7，从检查项目状态创建条件分支。如果物品有库存，请在物品分区下将转换形状添加到“更新物品状态”状态。如果该项目缺货，请在 Librarian 分区下添加一个“拒绝借出”状态的转换形状。

9. 从“更新项目状态”状态，向“贷款”分区下的“记录贷款信息”状态添加一个转换形状。

10. 从“记录借出信息”状态，向“图书管理员”分区下的“确认借出”状态添加一个转换形状。

11. 在“形状”窗口中，单击“最终状态”形状，并将其添加到成员分区的底部。添加从拒绝贷款状态到最终操作状态的转换形状。添加另一个从“确认贷款”状态到“最终操作”状态的转换形状。

您完成的图表应该类似于图 3-22 中所示的图表。将图表保存为 UMLAct3_2 并退出 UMLet。

图 3-22 。完成的活动图

探索 GUI 设计

到目前为止，关于面向对象的分析和设计的讨论集中在应用的功能设计和内部处理的建模上。成功的现代软件应用依赖于一组丰富的图形用户界面(GUI)来向应用的用户展示该功能。

在现代软件系统中，应用最重要的一个方面是它与用户的交互有多好。用户通过在 DOS 提示符下键入神秘命令来与应用进行交互的日子已经一去不复返了。现代操作系统使用的图形用户界面在很大程度上是直观的。用户也已经习惯了商业办公应用的精致界面。用户已经开始期望 IT 部门内部开发的定制应用具有同样的易用性和直观性。

用户界面的设计不应该随意进行；相反，它应该与业务逻辑设计一起计划。大多数应用的成功是由用户对应用的反应来判断的。如果用户在与应用交互时不舒服，并且应用没有提高用户的生产力，那么它注定是失败的。对于用户来说，界面就是应用。业务逻辑代码有多原始和聪明并不重要；如果用户界面设计和实现得不好，应用将不会被用户接受。开发人员最好记住是用户驱动软件开发。

虽然 UML 不是专门为 GUI 设计而设计的，但是许多软件架构师和程序员使用 UML 图来帮助对应用的用户界面建模。

GUI 活动图

开发用户界面设计的第一步是进行任务分析，以发现用户将如何与系统交互。任务分析基于之前已经建模的用例及场景。然后，您可以开发活动图来模拟用户和系统之间的交互是如何发生的。使用前面的电影租赁应用示例，图 3-23 显示了一个活动图，该图模拟了租赁人员记录租赁信息所经历的活动。

图 3-23 。用活动图进行 GUI 建模

界面原型

在您确定了必要的任务并对其进行了优先级排序之后，您就可以开发出构成用户界面的各种屏幕的原型草图了。图 3-24 显示了客户信息屏幕的原型草图。虽然你可以用纸和笔来开发你的图表，但是有一些很好的 GUI 原型工具可以提供通用的 GUI 设计模板和链接屏幕的能力，以及其他有用的特性。一些流行的商业原型工具包括微软的 SketchFlow、Balsamiq Mockups 和 AppMockupTools。一些流行的免费工具是铅笔项目，知更鸟和原型作曲家。图 3-24 所示的原型是使用铅笔投影工具创建的。

图 3-24 。GUI 原型草图

界面流程图

一旦你原型化了不同的屏幕，你就可以使用界面流程图来建模组成用户界面的屏幕之间的关系和流程模式。图 3-25 显示了视频租赁应用的部分界面流程图。

图 3-25 。界面流程图

应用原型

一旦你完成了屏幕布局和用户界面的设计，你就可以开发一个简单的原型。原型应该包含模拟系统功能的框架代码。在这一点上，您不应该花大力气将用户界面前端与应用的业务功能集成在一起。这个想法是让用户与一个工作原型交互，在用户界面上产生反馈。重要的是用户对界面设计感到舒适，并且使用起来直观。如果界面对用户来说很麻烦，不能提高他们的生产力，那么应用注定会失败。

改进和测试用户界面的过程将是反复的，很可能会持续几个周期。一旦应用的用户界面设计和内部功能设计已经完成并原型化，应用开发周期的下一步就是开始编码应用。

摘要

本章介绍了场景、序列图、协作图和活动图。您看到了如何使用这些图来建模对象交互。此外，您还了解了如何使用一些 UML 图来帮助对应用的用户界面进行建模。

这一章和前几章的目标是向你介绍一些软件设计和 UML 中涉及到的通用建模图和概念。在第四章的中，您将获得目前为止开发的概念，并使用它们来实现一个示例案例研究的解决方案设计。

活动答案

活动 3-1 答案

Member、Librarian、Item、Loan、LoanHistory。这五个对象包含在场景中描述的处理中。

该场景中描述的其他消息传递交互如下:

1. Librarian对象用LoanHistory对象检查Member对象的借出历史。
2. Librarian对象通过Item对象检查物品的可用性。
3. Librarian对象通过Item对象更新物品的可用性。
4. Librarian创建一个包含贷款信息的Loan对象。
5. Librarian将贷款信息返回给Member对象。

活动 3-2 答案

A.Member、B. Librarian、C. Item、D. LoanHistory、E. Item、F. Loan、G. Loan、H. Librarian。

Member对象负责请求电影活动。Librarian对象负责处理租赁和确认租赁活动。LoanHistory对象负责检查成员的贷款状态活动。Item对象负责检查可用性和更新物品状态活动。Loan对象负责计算到期日和记录租赁信息活动。

四、设计面向对象的解决方案：案例研究

为应用设计解决方案不是一件容易的事情。成为一名有成就的设计师需要时间和有意识的努力，这解释了为什么许多开发人员像躲避瘟疫一样躲避它。你可以研究理论，知道术语，但是真正发展你的建模技能的唯一方法是卷起袖子，弄脏你的手，开始建模。在本章中，您将了解办公用品订购系统的建模过程。虽然这不是一个复杂的应用，但是它包含了几个很好的用例，并且将由多个具有丰富的类交互的类组成。通过分析案例研究，您将更好地理解模型是如何开发的，以及各个部分是如何组合在一起的。

阅读本章后，您应该熟悉以下内容:

• 如何使用 UML 为 OOP 解决方案建模
• 要避免的一些常见 OOP 设计陷阱

开发面向对象的解决方案

在案例研究场景中，您的公司目前没有标准的部门订购办公用品的方式。每个部门分别实施自己的订购流程。因此，几乎不可能跟踪公司范围内的供应支出，这会影响预测预算和识别滥用的能力。当前系统的另一个问题是，它不允许单个联系人可以与各种供应商协商更好的交易。

因此，您被要求帮助开发一个公司范围的办公用品订购(OSO)应用。要对此系统进行建模，您需要完成以下步骤:

• 创建软件需求规范(SRS)
• 开发用例
• 绘制用例图表
• 给班级建模
• 为用户界面设计建模

创建系统需求规格

在与提议系统的各种客户面谈之后，您开发 SRS。请记住第二章中的内容，SRS 确定了系统需求的范围，定义了系统边界，并确定了系统的用户。

您已经确定了以下系统用户:

• 购买者:发起供货请求
• 部门经理:跟踪并批准部门采购员的供货请求
• 供应商处理申请:接收系统生成的订单文件
• 采购经理:更新供应目录，跟踪供应请求，并登记交付的物品

您已经确定了以下系统要求:

• 用户必须通过提供用户名和密码来登录系统。
• 购买者将查看可供订购的供应品列表。
• 购买者将能够按类别过滤供应品清单。
• 采购员可以在一个采购请求中请求多个供应。
• 部门经理可以为部门申请一般用品。
• 部门经理必须在每周末批准或拒绝其部门的供应请求。
• 如果部门经理拒绝请求，他们必须提供一个简短的解释，概述拒绝的原因。
• 部门经理必须跟踪其部门内的支出，并确保有足够的资金用于批准的供应请求。
• 采购经理维护供应目录，并确保其准确和最新。
• 采购经理在收到供应品时进行登记，并组织供应品进行配送。
• 已被请求但未被批准的供应请求标有待定状态。
• 已批准的供应请求标有状态已批准，并生成订单。
• 订单生成后，包含订单详细信息的文件将被放入订单队列。一旦订单被放入队列，它将被标记为状态已放置。
• 一个单独的供应商处理应用将从队列中检索订单文件，解析文档，并将行项目分发到适当的供应商队列。供应商处理应用会定期从供应商队列中检索订单，并将它们发送给供应商。(这是由一个单独的团队开发的。)
• 当订单的所有项目都被登记时，订单被标记为已履行状态，买方被告知订单已准备好提货。

开发用例

在生成 SRS 并让适当的系统用户签字后，下一个任务是开发用例，它将从用户的角度定义系统将如何运行。开发用例的第一步是定义参与者。请记住第二章中的角色代表将与系统交互的外部实体(人类或其他系统)。从 SRS 中，您可以确定以下将与系统交互的参与者:

• 买方
• 部门经理
• 采购经理
• 供应商处理申请

既然您已经确定了参与者，下一步就是确定参与者将涉及的各种用例。通过检查 SRS 中的需求陈述，您可以识别各种用例。例如,“用户必须通过提供用户名和密码来登录系统”这句话表明需要一个登录用例。表 4-1 确定了 OSO 应用的用例。

表 4-1 。OSO 应用的用例

名字	演员	描述
注册	采购员、部门经理、采购经理	用户会看到登录屏幕。然后，他们输入用户名和密码。他们要么点击登录，要么点击取消。登录后，他们会看到一个包含产品信息的屏幕。
查看供应目录	采购员、部门经理、采购经理	用户会看到一个包含供应品列表的目录表。该表包含供应名称、类别、描述和成本等信息。用户可以按类别过滤供应品。
购买申请	采购员、部门经理	购买者在表格中选择商品，然后点击按钮将它们添加到购物车中。一个单独的表显示了他们购物车中的商品、所请求的每个商品的数量和成本，以及请求的总成本。
部门采购请求	部门经理	部门经理在表格中选择商品，然后单击按钮将它们添加到购物车中。一个单独的表显示了他们购物车中的商品、所请求的每个商品的数量和成本，以及请求的总成本。
请求审查	部门经理	部门经理会看到一个屏幕，其中列出了他们部门成员的所有待定供应请求。他们审查请求，并将其标记为批准或拒绝。如果他们拒绝请求，他们输入一个简短的解释。
跟踪支出	部门经理	部门经理会看到一个屏幕，上面列出了部门成员每月的支出以及部门的总支出。
维护目录	采购经理	采购经理能够更新产品信息、添加产品或将产品标记为停产。管理员还可以更新类别信息、添加类别，以及将类别标记为停止使用。
项目签入	采购经理	采购经理看到一个输入订单号的屏幕。然后，采购经理会看到为订单列出的行项目。已接收的物料被标记。当收到订单的所有项目时，它会被标记为已履行。
下单	供应商处理应用	供应商处理应用检查队列中的外发订单文件。文件被检索、解析并发送到适当的供应商队列。

绘制用例图表

既然您已经确定了各种用例以及参与者，那么您就准备好构建用例的图表了。图 4-1 显示了一个用 UMLet 开发的初步用例模型，它在第二章中有介绍。

图 4-1 。初步的 OSO 用例图

在您绘制了用例之后，您现在要寻找用例之间可能存在的任何关系。可能存在的两种关系是包含关系和扩展关系。从第二章的讨论中记住，当一个用例包含另一个用例时，被包含的用例需要作为先决条件运行。例如，OSO 应用的登录用例需要包含在查看供应目录用例中。将登录作为一个单独的用例的原因是，登录用例可以被一个或多个其他用例重用。在 OSO 应用中，登录用例也将包含在跟踪支出用例中。图 4-2 描绘了这种包含关系。

图 4-2 。包括登录用例

注意在一些建模工具中，包含关系可以在用例图中通过 uses 关键字来表示。

当一个用例将扩展初始用例的行为时，扩展关系存在于两个用例之间。在 OSO 应用中，当经理提出采购请求时，她可以表明她将为部门提出采购请求。在这种情况下，部门购买请求用例成为购买请求用例的扩展。 图 4-3 图示此扩展。

图 4-3 。扩展购买请求用例

在分析了系统需求和用例之后，你可以通过分解应用并分阶段开发来使系统开发更易于管理。例如，您可以首先开发应用的购买请求部分。接下来，您可以开发请求检查部分，然后是项目签入部分。本章的其余部分集中在应用的购买请求部分。员工和部门经理将使用应用的这一部分来提出购买请求。图 4-4 显示了这个阶段的用例图。

图 4-4 。采购申请用例图

开发班级模型

开发类模型包括几项任务。首先确定类，然后添加属性、关联和行为。

识别类别

在您确定了各种用例之后，您可以开始确定系统需要包含的类，以执行用例中描述的功能。为了识别这些类，您需要深入到每个用例中，并定义一系列执行用例所需的步骤。识别用例描述中的名词短语也很有帮助。名词短语通常是将需要的类的良好指示器。

例如，以下步骤描述了查看供应目录用例:

• 用户已登录并被分配了用户状态级别。(这是前提条件。)
• 向用户呈现包含供应品列表的目录表。该表包含供应名称、类别、描述和成本等信息。
• 用户可以按类别过滤供应品。
• 用户可以选择注销或提出购买请求。(这是岗位条件。)

从这个描述中，您可以确定一个负责从数据库中检索产品信息并过滤所显示产品的类。这个类的名称将是ProductCatalog类。

检查处理购买请求的用例描述中的名词短语揭示了 OSO 应用的候选类，如表 4-2 中所列。

表 4-2 。用于提出购买请求的候选类别

用例	候选类别
注册	用户、用户名、密码、成功、失败
查看供应目录	用户、目录表、供应品列表、信息、供应品名称、类别、描述、成本
购买申请	购买者、物品、购物车、编号、请求的物品、成本、总成本
部门采购请求	部门经理、物品、购物车、编号、请求的物品、成本、总成本、部门采购请求

既然您已经确定了候选类，那么您需要排除那些表示冗余的类。例如，对项目和行项目的引用将代表相同的抽象。您还可以消除表示属性而不是对象的类。用户名、密码和费用是表示属性的名词短语的例子。有些类是模糊的，或者是其他类的概括。用户其实是采购员和经理的概括。类也可能实际上引用相同的对象抽象，但是指示对象的不同状态。例如，供应请求和订单在批准前和批准后代表相同的抽象。您还应该过滤掉表示实现结构的类，如 list 和 table。例如，购物车实际上是组成订单的订单项目的集合。

使用这些排除标准，您可以将类别列表缩减到以下候选类别:

• Employee
• DepartmentManager
• Order
• OrderItem
• ProductCatalog
• Product

现在，您可以开始为 OSO 应用的购买请求部分设计类图了。图 4-5 显示了 OSO 应用的初步类图。

图 4-5 。初步 OSO 类图

向类添加属性

开发类模型的下一个阶段是确定类必须实现的抽象层次。您可以确定哪些州信息与 OSO 应用相关。这个必需的状态信息将通过类的属性来实现。分析Employee类的系统需求揭示了对登录名、密码和部门的需求。您还需要一个标识符，比如员工 ID，来唯一地标识不同的员工。对经理的采访显示，需要包括雇员的名和姓，以便他们可以通过名字跟踪支出。表 4-3 总结了将包含在 OSO 类中的属性。

表 4-3。 OSO 类属性

类	属性	类型
Employee	EmployeeID
LoginName
Password
Department
FirstName
整数
串
串
串
串
串
DepartmentManager	EmployeeID
LoginName
Password
Department
FirstName
整数
串
串
串
串
串
Order	OrderNumber
OrderDate
长
日期
字符串
OrderItem	ProductNumber
Quantity
字符串
整数
小数
Product	ProductNumber
ProductName
Description
UnitPrice
Category
字符串
字符串
字符串
小数
字符串
字符串
ProductCatalog	没有人

图 4-6 显示了到目前为止已经确定了类属性的 OSO 类图。

图 4-6 。添加了属性的购买请求组件类图

识别类别关联

开发过程的下一步是对 OSO 应用中存在的类关联进行建模。如果你研究了用例以及 SRS，你就能理解你需要在类结构设计中加入什么类型的关联。

注意你可能会发现你需要进一步细化 SRS 来暴露类关联。

例如，一个雇员将与一个订单相关联。通过检查关联的多样性，您会发现一个雇员可以有多个订单，但是一个订单只能与一个雇员相关联。图 4-7 模拟了这种关联。

图 4-7 。描述雇员类和订单类之间的关联

当您开始识别类属性时，您会注意到Employee类和DepartmentManager类有许多相同的属性。这是有道理的，因为经理也是员工。在本应用中，经理代表具有特殊行为的员工。这种专门化由继承关系来表示，如图图 4-8 所示。

图 4-8 。DepartmentManager 类继承自 Employee 类

以下陈述总结了 OSO 类结构中的关联:

• 一个Order是一个OrderItem对象的集合。
• 一个Employee可以有多个Order对象。
• 一个Order与一个Employee相关联。
• ProductCatalog与多个Product对象相关联。
• 一个Product与ProductCatalog相关联。
• 一个OrderItem与一个Product相关联。
• 一个Product可能与多个OrderItem对象相关联。
• 一个DepartmentManager是一个具有专门行为的Employee。

图 4-9 显示了这些不同的关联(为了清楚起见，不包括类属性)。

图 4-9 。添加了关联的采购请求组件类图

类行为建模

既然您已经勾勒出了类的初步结构，那么您就可以对这些类如何交互和协作进行建模了。这个过程的第一步是深入到用例描述中，并创建一个用例将如何执行的更详细的场景。下面的场景描述了执行登录用例的一个可能的顺序。

1. 用户会看到一个登录对话框。
2. 用户输入登录名和密码。
3. 用户提交信息。
4. 检查并验证名称和密码。
5. 向用户呈现供应请求屏幕。

尽管这个场景描述了登录用例中最常见的处理，但是您可能需要其他场景来描述预期的替代结果。以下场景描述了登录用例的另一种处理方式:

1. 用户会看到一个登录对话框。
2. 用户输入登录名和密码。
3. 用户提交信息。
4. 已检查名称和密码，但无法验证。
5. 用户被告知不正确的登录信息。
6. 再次向用户显示登录对话框。
7. 用户要么重试，要么取消登录请求。

在这一点上，它可能有助于创建用例场景的可视化表示。记住第三章中的活动图经常被用来可视化用例处理。图 4-10 显示了为登录用例场景构建的活动图。

图 4-10 。描述登录用例场景的活动图

在分析了用例场景中所涉及的过程之后，您现在可以将注意力转向为系统的类分配必要的行为。为了帮助识别需要发生的类行为和交互，你构建一个序列图，如第三章中所讨论的。

图 4-11 显示了登录用例场景的序列图。Purchaser (UI )类调用已经分配给Employee类的Login方法。该消息返回指示登录是否已被验证的信息。

图 4-11 。描述登录用例场景的序列图

接下来，让我们分析一下视图供应目录用例。以下场景描述了用例:

1. 用户已登录并通过验证。
2. 用户查看包含产品信息的目录表，包括供应名称、类别、描述和价格。
3. 用户选择按类别过滤表格，选择一个类别，然后刷新表格。

从这个场景中，您可以看到您需要一个ProductCatalog类的方法来返回产品类别列表。Purchaser类将调用这个方法。ProductCatalog类需要的另一个方法是返回按类别过滤的产品列表。图 4-12 中的序列图显示了Purchaser (UI)类和ProductCatalog类之间的交互。

图 4-12 。描述查看供应目录方案的序列图

以下场景是为购买请求用例开发的:

1. 一名采购人员已经登录并被确认为员工。
2. 购买者从产品目录中选择商品，并将它们添加到订单请求(购物车)中，指明所请求的每个商品的数量。
3. 在完成订单的项目选择之后，购买者提交订单。
4. 订单请求信息被更新，订单 ID 被生成并返回给购买者。

从这个场景中，您可以确定需要创建的Order类的AddItem方法。该方法将接受产品 ID 和数量，然后返回订购产品的小计。Order类需要调用OrderItem类的方法，这将创建一个订单项的实例。您还需要一个Order类的SubmitOrder方法，该方法将提交请求和生成订单的退货订单 ID。图 4-13 显示了该场景的相关序列图。

图 4-13 。描述购买请求场景的序列图

需要包括的一些其他场景是从购物车中删除商品、更改购物车中商品的数量以及取消订单流程。您还需要为部门采购请求用例包含类似的场景并创建类似的方法。在分析了需要发生的场景和交互之后，你可以为应用的购买请求部分开发一个类图，如图 4-14 所示。

图 4-14 。采购申请类图

开发用户界面模型设计

在应用设计过程的这一点上，您不希望提交特定的 GUI 实现(换句话说，特定于技术的实现)。然而，对应用的 GUI 所需的一些公共元素和功能进行建模是有帮助的。这将帮助您创建一个原型用户界面，您可以用它来验证已经开发的业务逻辑设计。用户将能够与原型互动，并提供反馈和逻辑设计的验证。

您需要实现的第一个原型屏幕是用于登录的屏幕。您可以构建一个活动图来帮助定义用户登录系统时需要执行的活动，如图图 4-15 所示。

图 4-15 。描述用户登录活动的活动图

分析活动图可以发现，您可以将登录屏幕实现为一个相当通用的界面。该屏幕应该允许用户输入用户名和密码。它应该包括一种方式来表明用户是作为雇员还是经理登录的。经理必须以员工身份登录才能提出购买请求，以经理身份登录才能批准请求。最后的要求是包括一个让用户中止登录过程的方法。图 4-16 显示了登录屏幕的原型。

图 4-16 。登录屏幕原型

您需要考虑的下一个屏幕是产品目录屏幕。图 4-17 描述了查看和过滤产品的活动图。

图 4-17 。描述产品浏览活动的活动图

活动图显示屏幕需要显示产品和产品信息的表格或列表。用户必须能够按类别过滤产品，这可以通过从类别列表中选择一个类别来启动。用户还需要能够发起订单请求或退出应用。图 4-18 显示了可用于查看产品的原型屏幕。单击添加到订单按钮将产品添加到订单，并启动订单详细信息屏幕，用户可以在其中调整订单数量。

图 4-18 。查看产品屏幕原型

应用的这一部分需要原型化的最后一个屏幕是购物车界面。这将有助于从订单请求中添加和删除项目。它还需要允许用户提交订单或中止订单请求。图 4-19 显示了订单请求屏幕的原型。单击添加按钮将启动之前的产品目录屏幕，允许用户添加其他行项目。移除按钮将移除选中的行项目。用户可以通过单击向上和向下箭头来更改行项目的数量。

图 4-19 。订单详细信息屏幕原型

这就完成了 OSO 应用这一阶段的初步设计。你应用了你在第二章和第三章中学到的知识来设计模型。接下来，让我们回顾一下在这个过程中要避免的一些常见错误。

避免一些常见的 OOP 设计陷阱

当你开始为自己的 OOP 设计建模时，你希望确保遵循最佳实践。以下是一些你应该避免的常见陷阱

• 不要让用户参与过程:值得强调的是，用户是你产品的消费者。他们是定义系统的业务流程和功能需求的人。
• 尝试一次性建模整个解决方案:当开发复杂系统时，将系统设计和开发分解成可管理的组件。计划分阶段生产软件。这将提供更快的建模、开发、测试和发布周期。
• 努力打造完美模型:没有一个模型从一开始就是完美的。成功的建模者明白建模过程是迭代的，模型在整个应用开发周期中不断更新和修改。
• 认为只有一种真正的建模方法:正如有许多不同的同样可行的 OOP 语言一样，也有许多同样有效的软件开发建模方法。选择一个最适合你和手头项目的。
• 重新发明轮子:寻找模式和可重用性。如果您分析应用试图解决的许多业务流程，就会出现一组一致的建模模式。创建一个存储库，您可以在其中从一个项目到另一个项目，从一个程序员到另一个程序员利用这些现有的模式。
• 让数据模型驱动业务逻辑模型:首先开发数据模型(数据库结构)，然后在其上构建业务逻辑设计，这通常不是一个好主意。解决方案设计者应该首先询问需要解决什么业务问题，然后建立数据模型来解决问题。
• 混淆问题域模型和实现模型:在设计应用时，你应该开发两个不同但互补的模型。领域模型设计描述了项目的范围和实现业务解决方案所涉及的处理。这包括将涉及哪些对象，它们的属性和行为，以及它们如何相互作用和关联。领域模型应该是与实现无关的。您应该能够使用同一个域模型作为几种不同的特定于架构的实现的基础。换句话说，您应该能够采用相同的域模型，并使用 Visual Basic 富客户端、两层架构或 C#(或 Java)n 层分布式 web 应用来实现它。

摘要

现在，您已经分析了 OOP 应用的领域模型，您已经准备好将设计转化为实际的实现了。本书的下一部分将向你介绍 C# 语言。你会看到 .NET 框架，并了解如何在框架之上构建 C# 应用。将向您介绍如何使用 Visual Studio IDE，并熟悉 C# 语言的语法。下一节还将演示在 C# 中实现 OOP 结构的过程，比如类结构、对象实例化、继承和多态。利用你新获得的技能，你将重温本章介绍的案例研究，并应用这些技能将应用设计转化为一个功能性的应用。

五、.NET 框架和 Visual Studio 简介

业务应用编程已经从两层、紧耦合的模型发展成多层、松耦合的模型，通常涉及通过互联网或公司内部网的数据传输。为了让程序员更有效率并处理这种模型的复杂性，微软开发了 .NET 框架。为了有效地用 C# 编程，你需要理解构建它的底层框架。

阅读本章后，您应该熟悉以下内容:

• 那个 .NET 框架
• 公共语言运行库(CLR)的功能
• 实时(JIT)编译器的工作原理
• 那个 .NET Framework 基类库
• 命名空间和程序集
• Visual Studio 集成开发环境的功能

介绍 .NET 框架

那个 .NET Framework 是基础类的集合，旨在提供运行应用所需的公共服务。让我们看看的目标 .NET 框架，然后查看它的组件。

的目标 .NET 框架

微软设计了 .NET 框架，并考虑到某些目标。下面几节研究这些目标以及 .NET 框架实现了它们。

行业标准的支持

微软想要的是 .NET 框架基于行业标准和实践。因此，该框架严重依赖于行业标准，如可扩展标记语言(XML)、HTML 5 和 OData。微软还向欧洲计算机制造商协会(ECMA)提交了一份公共语言基础设施(CLI)工作文件，该协会负责监督计算机行业的许多公共标准。

CLI 是创建符合 .NET 框架。第三方供应商可以使用这些规范来创建。符合. NET 的语言编译器；例如，交互式软件工程(ISE)已经为 Eiffel 创建了一个. NET 编译器。第三方供应商也可以创建一个 CLR 来允许 .NET 兼容的语言在不同的平台上运行。例如，Mono 是 CLR 的开源、跨平台实现，它赋予 C# 应用在 Linux 平台上运行的能力。

展开性

为了创建一个高效的编程环境，微软实现了 .NET 框架必须是可扩展的。于是，微软向开发者公开了框架类层次结构。通过继承和接口，您可以轻松地访问和扩展这些类的功能。例如，您可以创建一个按钮控件类，它不仅从 .NET Framework，而且以应用所需的独特方式扩展了基本功能。

微软还使底层操作系统的使用变得更加容易。通过在基于类的层次结构中重新打包和实现 Windows 操作系统应用编程接口(API)函数，微软使面向对象编程人员能够更直观、更容易地使用底层操作系统提供的功能。

统一编程模型

微软的另一个重要目标是 .NET 框架是跨语言独立和集成的。为了实现这个目标，所有支持公共语言规范(CLS)的语言都编译成相同的中间语言，支持相同的基本数据类型集，并公开相同的代码可访问性方法集。结果，不仅用不同的 CLS 兼容语言开发的类可以无缝地相互通信，而且你还可以跨语言实现 OOP 结构。例如，您可以开发一个用 C# 编写的类，该类继承自用 Visual Basic (VB)编写的类。微软已经开发了几种支持 .NET 框架。除了 C#，这些语言还有 VB.NET、托管 C++、JScript 和 F#。除了这些语言之外，许多第三方供应商还开发了其他流行语言的版本，用于在 .NET 框架，比如 Pascal 和 Python。

更容易部署

微软需要一种方法来简化应用部署。以前的发展 .NET Framework 中，当部署组件时，组件信息必须记录在系统注册表中。许多这些组件，尤其是系统组件，被几个不同的客户端应用使用。当客户端应用调用该组件时，会搜索注册表以确定使用该组件所需的元数据。如果部署了较新版本的组件，它将替换旧组件的注册表信息。通常，新组件与旧版本不兼容，导致现有客户端出现故障。您可能在安装了一个服务包后遇到过这个问题，该服务包导致的问题比它修复的问题还多！

那个 .NET Framework 通过将用于处理组件的元数据存储在一个名为清单的文件中来解决这个问题，该文件打包在包含组件代码的程序集中。程序集是包含运行应用所需的代码、资源和元数据的包。默认情况下，程序集被标记为私有，并与客户端程序集放在同一目录中。这确保了组件组合不会被无意中替换或修改，并且还允许更简单的部署，因为不需要使用注册表。如果需要共享一个组件，它的程序集被部署到一个称为全局程序集缓存(GAC)的特殊目录中。程序集的清单包含版本信息，因此组件的较新版本可以与 GAC 中的较旧版本并行部署。默认情况下，客户端程序集继续请求和使用它们打算使用的组件版本。当安装组件的新版本时，旧的客户端程序集将不再失败。

改进的内存管理

为 Windows 平台开发的程序的一个常见问题是内存管理。通常，这些程序会导致内存泄漏。当程序从操作系统分配内存，但在完成内存工作后未能释放内存时，就会发生内存泄漏。该内存不再可用于其他应用或操作系统，导致计算机运行缓慢，甚至停止响应。当程序打算长时间运行时，例如在后台运行的服务，这个问题就更复杂了。为了解决这个问题 .NET Framework 使用不确定的终结。框架使用垃圾收集对象，而不是依赖应用来释放未使用的内存。垃圾收集器定期扫描未使用的内存块，并将它们返回给操作系统。

改进的安全模型

在当今高度分布式、基于互联网的应用中实现安全性是一个极其重要的问题。过去，安全性主要集中在应用的用户身上。当用户登录到应用时，会检查安全身份，当应用调用远程服务器和数据库时，会传递用户的身份。对于当今企业级的松散耦合系统来说，这种类型的安全模型被证明是低效且难以实现的。为了使安全性更容易实现和更健壮 .NET Framework 使用代码标识和代码访问的概念。

创建程序集时，它会被赋予一个唯一的标识。创建服务器程序集时，您可以授予访问权限和权利。当客户端程序集调用服务器程序集时，运行库将检查客户端的权限和权利，然后相应地授予或拒绝对服务器代码的访问。因为每个程序集都有一个标识，所以还可以通过操作系统限制对程序集的访问。例如，如果用户从 Web 下载一个组件，您可以限制该组件在用户系统上读写文件的能力。

的组件 .NET 框架

现在您已经看到了的一些主要目标 .NET 框架，我们来看看它包含的组件。

公共语言运行时

的基本组件 .NET 框架是 CLR。CLR 管理正在执行的代码，并在代码和操作系统之间提供一个抽象层。CLR 内置了以下机制:

• 将代码加载到内存中并准备执行
• 将代码从中间语言转换为本机代码
• 管理代码执行
• 管理代码和用户级安全性
• 自动释放和释放内存
• 调试和跟踪代码执行
• 提供结构化异常处理

框架基础类库

构建在 CLR 之上的是 .NET 框架基础类库。这个类库中包括引用类型和值类型，它们封装了对系统功能的访问。类型是数据结构。引用类型是一种复杂类型，例如类和接口。值类型是简单类型，例如整数或布尔。程序员使用这些基类和接口作为构建应用、组件和控件的基础。基本类库包括封装数据结构、执行基本输入/输出操作、调用安全管理、管理网络通信以及执行许多其他功能的类型。

数据类别

构建在基类之上的是支持数据管理的类。这组类通常被称为 ADO.NET。使用 ADO.NET 对象模型，程序员可以通过托管提供程序访问和管理存储在各种数据存储结构中的数据。微软已经编写并调整了 ADO.NET 类和对象模型，以便在松散耦合、互不连接的多层环境中高效工作。ADO.NET 不仅公开数据库中的数据，还公开与数据相关联的元数据。数据被公开为一种小型关系数据库。这意味着您可以在与数据源断开连接的情况下获取和使用数据，并在以后将数据与数据源同步。

微软已经为几个数据提供者提供了支持。存储在 Microsoft SQL Server 中的数据可以通过本机 SQL 数据提供程序进行访问。OLEDB 和开放式数据库连接管理(ODBC)提供程序是目前通过 OLEDB 或 ODBC 标准 API 公开的系统的两个通用提供程序。因为这些托管数据提供程序不直接与数据库引擎交互，而是与非托管提供程序进行通信，然后由非托管提供程序与数据库引擎进行通信，所以使用非本机数据提供程序比使用本机提供程序效率更低、功能更弱。由于 .NET 框架和微软对基于开放标准的承诺，许多数据存储供应商现在为他们的系统提供本地数据提供者。

建立在 ADO.NET 提供者模型之上的是 ADO.NET 实体框架。实体框架在数据库的关系数据结构和编程语言的面向对象结构之间架起了一座桥梁。它提供了一个对象/关系映射(ORM)框架，使得程序员无需为数据访问编写大部分管道代码。该框架提供诸如变更跟踪、身份解析和查询翻译等服务。程序员使用语言集成查询(LINQ)来检索数据，并将数据作为强类型对象来操作。第十章详细介绍 ADO.NET 和数据访问。

Windows 应用

在此之前。根据您是使用 C++还是 Visual Basic 进行开发，开发 Windows 图形用户界面(GUI)会有很大的不同。尽管用 VB 开发 GUI 很容易，而且可以很快完成，但 VB 开发人员与 Windows API 的底层功能隔离开来，没有完全接触到它。另一方面，尽管接触到了 Windows API 的全部功能，但用 C++开发 GUI 是非常乏味和耗时的。与 .NET Framework 中，微软引入了一组基类，在。与. NET 兼容的语言。这使得 Windows GUI 开发在各种 .NET 支持的编程语言，结合了开发的简易性和 API 的全部特性。

除了传统的 Windows 窗体和控件(自 Windows 操作系统出现以来就一直存在)之外 .NET Framework 包括一组类，统称为 Windows 演示基础(WPF)。WPF 集成了一个渲染引擎，旨在利用现代图形硬件和丰富的操作系统，如 Windows 7。它还包括应用开发功能，如控件、数据绑定、布局、图形和动画。有了 WPF 的类集，程序员可以创建提供非常引人注目的用户体验的应用。在第十一章中，你将更深入地了解如何构建基于 WPF 的应用。

网络应用

那个 .NET Framework 公开了一组基本类，可用于在 web 服务器上创建向启用 web 的客户端公开的用户界面和服务。这些类统称为 ASP.NET。使用 ASP.NET，您可以开发一个用户界面，它可以动态地响应发出请求的客户端设备的类型。在运行时 .NET Framework 负责发现发出请求的客户端的类型(浏览器类型和版本)并公开适当的接口。运行在 Windows 客户机上的 web 应用的 GUI 变得更加健壮，因为 .NET Framework 公开了许多 API 功能，这些功能以前只向传统的基于 Windows 窗体的 C++和 VB 应用公开。使用 .NET Framework 的一个优点是服务器端代码可以用任何。符合. NET 的语言。之前 .NET 中，服务器端代码必须用脚本语言编写，如 VBScript 或 JScript。

Visual Studio 2012 和 .NET framework 4.5 支持几种不同的创建 web 应用的模型。您可以基于 ASP.NET web 窗体项目、ASP.NET MVC 项目或 Silverlight 应用项目创建 Web 应用。第十二章涵盖了开发网络应用。

Windows 应用商店应用

一种新类型的 Windows 应用可用于 Windows 8 操作系统:Windows 商店应用。Windows 应用商店应用面向平板电脑和手机等利用触摸屏进行用户输入和持续互联网连接的设备。构建 Windows 应用商店应用有两种选择。您可以使用 .NET 语言(C#/VB/C++)与 XAML 结合使用，或者您可以将 JavaScript 与 HTML5 结合使用。Windows 应用商店应用是使用 WinRT API 构建的，这类似于针对。网络工作。微软甚至增加了一个. NET 框架 API 作为 WinRT API 的包装。这意味着您可以使用 .NET Framework 来使用您已经熟悉的编程语言和设计经验创建出色的 Windows 应用商店应用。事实上，正如你将在第十三章中看到的，使用 C# 和 XAML 创建 Windows Store 应用与构建 WPF 应用非常相似。

应用服务程序

包括在 .NET Framework 是基类和接口支持，用于公开可由其他应用使用的服务。在…之前 .NET 框架，用 C++和 VB 开发的应用使用了分布式组件对象模型(DCOM)技术。DCOM 是一种在分布于联网计算机上的软件组件之间进行通信的技术。因为 DCOM 是基于二进制标准的，所以通过防火墙和互联网的应用到应用的通信不容易实现。DCOM 的专有性质也限制了能够有效使用通过 COM 公开服务的应用并与之交互的客户端类型。

微软通过互联网标准公开服务来解决这些限制。包括在 .NET 框架是一组类，统称为 Windows 通信基础(WCF) 。使用 WCF，您可以将数据作为消息从一个应用发送到另一个应用。消息传输和内容可以根据消费者和环境轻松更改。例如，如果服务是通过 Web 公开的，那么可以使用基于 HTTP 的文本消息。另一方面，如果客户端在同一个公司网络上，则可以使用 TCP 上的二进制消息。

和。除了. NET 4.5 之外，微软还引入了一种新的创建 HTTP 服务的框架，称为 ASP.NET Web API。使用这个 API，您可以构建能够到达各种客户端的服务，比如 web 浏览器和移动设备。虽然您可以使用 WCF 创建这些服务，但新的 Web API 使其更容易实现，并包括内容协商、查询合成和灵活托管等功能。在第十四章中，你将使用 ASP.NET Web API 和 WCF 创建和消费应用服务。

使用 .NET 框架

使用 .NET Framework，您应该了解它是如何构造的，以及托管代码是如何编译和执行的。 .NET 应用被组织并打包成程序集。由执行的所有代码 .NET 运行库必须包含在程序集中。

了解程序集和清单

程序集包含运行应用所需的代码、资源和清单(关于程序集的元数据)。组件可以被组织成一个文件，其中所有的信息都被合并到一个动态链接库(DLL)文件或可执行(EXE)文件中，或者被组织成多个文件，其中信息被合并到单独的 DLL 文件、图形文件和清单文件中。程序集的主要功能之一是形成类型、引用和安全性的边界。大会的另一个重要功能是组成一个部署单位。

程序集最重要的部分之一是清单；事实上，每个程序集都必须包含一个清单。清单的目的是描述程序集。它包含程序集的标识、程序集向客户端公开的类和其他数据类型的说明、此程序集需要引用的任何其他程序集以及运行程序集所需的安全详细信息。

默认情况下，当创建程序集时，它被标记为私有。程序集的副本必须放在使用它的任何客户端程序集的同一目录或 bin 子目录中。如果程序集必须在多个客户端程序集之间共享，则它被放在全局程序集缓存(GAC) 中，这是一个特殊的 Windows 文件夹。若要将私有程序集转换为共享程序集，必须运行实用程序来创建加密密钥，并且必须用密钥对程序集进行签名。对程序集签名后，必须使用另一个实用工具将共享程序集添加到 GAC 中。通过制定创建和公开共享程序集的严格要求，Microsoft 试图确保不会发生恶意篡改共享程序集的情况。这也确保了同一程序集的新版本可以存在，而不会破坏使用旧程序集的当前应用。

引用程序集和命名空间

来制造 .NET 框架更易于管理，微软给了它一个层次结构。这种分层结构被组织成所谓的名称空间。通过将框架组织到名称空间中，命名冲突的机会大大减少了。将框架的相关功能组织到名称空间中也极大地增强了其对开发人员的可用性。例如，如果您想构建一个窗口的 GUI，那么您需要的功能很可能存在于System.Windows名称空间中。

所有的 .NET Framework 类驻留在系统命名空间中。系统命名空间按功能进一步细分。使用数据库所需的功能包含在System.Data名称空间中。一些名称空间有几层深度；例如，用于连接到 SQL Server 数据库的功能包含在System.Data.SqlClient名称空间中。

程序集可以组织成单个命名空间或多个命名空间。几个程序集也可以组织到同一个命名空间中。

中的类进行访问 .NET Framework，您需要在代码中引用包含命名空间的程序集。然后，您可以通过提供类的完全限定名来访问程序集中的类。例如，如果您想在表单中添加一个文本框，您可以创建一个System.Windows.Controls.TextBox类的实例，如下所示:

private System.Windows.Controls.TextBox newTextBox;

幸运的是，在 C# 中，您可以在代码文件的顶部使用 using 语句，这样就不需要在代码中不断引用完全限定名:

using System.Windows.Controls;
private TextBox newTextBox;

编译和执行托管代码

什么时候 .NET 代码被编译，它被转换成. NET 可移植可执行(PE)文件。编译器将源代码翻译成微软中间语言(MSIL)格式。MSIL 是独立于 CPU 的代码，这意味着它需要在执行前进一步转换为特定于 CPU 的本机代码。

除了 MSIL 代码，PE 文件还包括清单中包含的元数据信息。PE 文件中元数据的合并使得代码可以自我描述。不需要附加的类型库或接口定义语言(IDL)文件。

因为各种 .NET 兼容的语言编译成相同的 MSIL 和元数据格式 .NET 平台支持语言集成。这超越了微软的 COM 组件，例如，用 VB 编写的客户端代码可以实例化和使用用 C++编写的组件的方法。和 .NET 语言集成，您可以用 VB 编写一个. NET 类，它继承了用 C# 编写的类，然后重写它的一些方法。

在执行 PE 文件中的 MSIL 代码之前，. NET Framework 实时(JIT)编译器会将其转换为特定于 CPU 的本机代码。为了提高效率，JIT 编译器不会同时将所有 MSIL 代码转换为本机代码。MSIL 代码根据需要进行转换。当执行一个方法时，编译器检查代码是否已经被转换并放入缓存。如果有，则使用编译版本；否则，MSIL 码将被转换并存储在缓存中以备将来调用。

因为 JIT 编译器是针对不同的 CPU 和操作系统编写的，所以开发人员不需要重写他们的应用来针对各种平台。可以想象，你为 Windows 服务器平台编写的程序也可以在 UNIX 服务器上运行。所需要的只是一个用于 UNIX 架构的 JIT 编译器。

使用 Visual Studio 集成开发环境

您可以使用简单的文本编辑器编写 C# 代码，并使用命令行编译器编译它。然而，您会发现，使用文本编辑器编写企业级应用可能会令人沮丧且效率低下。大多数以编程为生的程序员发现集成开发环境(IDE)在易用性和提高生产率方面非常有价值。微软在 Visual Studio (VS) 中开发了一个出色的 IDE。集成到 VS 中的许多特性使得 .NET Framework 更直观、更简单、更高效。Visual Studio 的一些有用功能包括:

• 编辑器功能，如自动语法检查、自动完成和颜色突出显示
• 一个 IDE 供所有人使用。网络语言
• 广泛的调试支持，包括设置断点、单步调试代码以及查看和修改变量的能力
• 集成帮助文档
• 拖放式 GUI 开发
• XML 和 HTML 编辑
• 与 Windows Installer 集成的自动化部署工具
• 从 IDE 中查看和管理服务器的能力
• 完全可定制和扩展的界面

下面的活动将向您介绍 VS IDE 中的一些特性。当您完成这些步骤时，不要担心编码细节。只需专注于习惯在 VS IDE 中工作。您将在接下来的章节中了解更多关于代码的内容。

注意如果没有安装 Visual Studio 2012，请参考附录 C 中的安装说明。

活动 5-1。游览 VISUAL STUDIO

在本活动中，您将熟悉以下内容:

• 自定义 IDE
• 创建. NET 项目并设置项目属性
• 使用 VS IDE 中的各种编辑器窗口
• 使用 VS IDE 的自动语法检查和自动完成功能
• 用 VS IDE 编译程序集

定制 IDE

要定制 IDE，请按照下列步骤操作:

1. Start Visual Studio 2012.

   注意如果这是你第一次启动 VS，你会被要求选择一个默认的开发设置。选择 Visual C# 开发设置。

2. 您将看到起始页。起始页包含几个窗格，其中一个窗格链接到 MSDN (Microsoft Developer Network)网站上发布的有用文档。点击其中的一个链接将会启动一个托管在 VS 中的浏览器窗口，打开 MSDN 网站上的文档。花些时间研究一下信息和起始页上显示给你的各种链接。

3. Microsoft has taken considerable effort to make VS a customizable design environment. You can customize just about every aspect of the layout, from the various windows and menus down to the color coding used in the code editor. Select Tools Options to open the Options dialog box, shown in Figure 5-1, which allows you to customize many aspects of the IDE.

   

   图 5-1 。VS 选项对话框

4. 在对话框左侧的“类别”列表中，单击“项目和解决方案”。您可以选择更改项目的默认位置，以及在构建和运行项目时会发生什么。选择“生成开始时显示输出窗口”选项。

5. 调查其他一些可用的可定制选项。完成后，单击确定按钮关闭选项对话框。

创建新项目

要创建一个新项目，请遵循以下步骤:

1. 在起始页上，单击“创建项目”链接，这将启动“新建项目”对话框。(您也可以选择文件新建项目来打开此对话框。)

2. “新建项目”对话框允许您使用内置模板创建各种项目。有创建 Windows 项目、Web 项目、WCF 项目以及许多其他项目的模板，这取决于您在安装 VS 时选择的选项

3. In the Templates pane, expand the Visual C# node and select the Windows node, as shown in Figure 5-2. Observe the various C# project templates. There are templates for creating various types of Windows applications, including Windows Forms-based applications, class libraries, and console applications.

   

   图 5-2 。VS 新建项目对话框

4. 单击 Windows 窗体应用模板。将应用的名称更改为 DemoChapter5，然后单击 OK 按钮。

当项目打开时，您将看到一个添加到项目中的默认表单(名为 Form1)的表单设计器。在此窗口的右侧，您应该会看到解决方案资源管理器。

调查解决方案资源管理器和类视图

解决方案资源管理器显示作为当前解决方案一部分的项目和文件，如图 5-3 所示。默认情况下，创建项目时，会创建一个与项目同名的解决方案。该解决方案包含一些全局信息、项目链接信息和定制设置，如任务列表和调试信息。一个解决方案可以包含多个相关项目。

图 5-3 。解决方案浏览器

解决方案节点下是项目节点。项目节点组织与项目相关的各种文件和设置。项目文件将这些信息组织在一个 XML 文档中，该文档包含对作为项目一部分的类文件的引用、项目所需的任何外部引用以及已设置的编译选项。项目节点下是属性节点、引用节点、App.config 文件、Form1类的类文件和Program类文件。

要练习使用解决方案资源管理器和一些 VS 特性和视图，请按照下列步骤操作:

1. 在“解决方案资源管理器”窗口中，右击“属性”节点并选择“打开”。这将启动项目属性窗口。窗口左侧是几个选项卡，您可以使用它们来浏览和设置各种应用设置。

2. Select the Application tab, as shown in Figure 5-4. Notice that, by default, the assembly name and default namespace are set to the name of the project.

   

   图 5-4 。项目属性窗口

3. 在“项目属性”窗口中浏览其他一些选项卡。完成后，单击窗口选项卡中的 x 关闭窗口。

4. 在"解决方案资源管理器"窗口中，展开"引用"节点。节点下是应用引用的外部程序集。请注意，默认情况下包含了几个引用。默认引用取决于项目的类型。例如，因为这是一个 Windows 应用项目，所以默认情况下包含对System.Windows.Forms名称空间的引用。

5. 解决方案资源管理器的项目节点下的Form1类文件有一个. cs 扩展名，表示它是用 C# 代码编写的。默认情况下，文件名已设置为与表单相同的名称。在解决方案资源管理器窗口中双击该文件。该窗体显示在设计视图中。单击 Solution Explorer 顶部工具栏中的 View Code 按钮，将会打开Form1类的代码编辑器。

6. 选择视图类视图以启动类视图窗口。“类视图”窗口的顶部按照命名空间层次结构组织项目文件。展开 DemoChapter5 根节点会显示三个子节点:引用节点、DemoChapter5 命名空间节点和 DemoChapter5 属性节点。名称空间节点由节点名称左侧的{}符号指定。

7. Listed under the DemoChapter5 namespace node are the classes that belong to the namespace. Expanding the Form1 node reveals a Base Types folder. Expanding Base Types shows the classes and interfaces inherited and implemented by the Form1 class, as shown in Figure 5-5. You can further expand the nodes to show the classes and interfaces inherited and implemented by the Form base class.

   

   图 5-5 。类视图中展开的节点

8. “类视图”窗口的底部是该类的方法、属性和事件的列表。选择“类视图”窗口顶部的“窗体”节点。请注意窗口底部列出了大量的方法、属性和事件。

9. Right-click the DemoChapter5 project node and select Add Class. Name the class DemoClass1 and click the Add button. If the class code is not visible in the code editor, double-click the DemoClass1 node in the Class View window to display it. Wrap the class definition code in a namespace declaration as follows:

   namespace DemoChapter5

   {

   namespace MyDemoNamespace

   {

   class DemoClass1

   {

   }

   }

   }

10. 请注意类视图中更新的层次结构。DemoClass1现在属于MyDemoNamespace，后者属于DemoChapter5名称空间。DemoClass1的全称现在是DemoChapter5.MyDemoNamespace.DemoClass1。

11. Add the following code to the DemoClass1 definition. As you add the code, notice the auto-selection drop-down list provided (see Figure 5-6). Pressing the Tab key will select the current item on the list.

`class DemoClass1: System.Collections.CaseInsensitiveComparer`

`{`

`}`

![9781430249351_Fig05-06.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig05-06.jpg)

图 5-6 。代码选择下拉列表

12. 请注意类视图中更新的层次结构。展开 DemoClass1 节点下的 Base Types 节点，您将看到 base CaseInsensitiveComparer类节点。选择该节点，您将在“类视图”窗口的下半部分看到CaseInsensitiveComparer类的方法和属性。
13. Right-click the Compare method of the CaseInsensitiveComparer class node and choose Browse Definition. The Object Browser window is opened as a tab in the main window and information about the Compare method is displayed. Notice it takes two object arguments, compares them, and returns an integer value based on the result (see Figure 5-7).

![9781430249351_Fig05-07.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig05-07.jpg)

图 5-7 。对象浏览器

14. 对象浏览器使您能够浏览对象层次结构，并查看有关层次结构中的项和方法的信息。花些时间探索对象浏览器。完成后，关闭对象浏览器并关闭"类视图"窗口。

探索工具箱和属性窗口

要浏览 VS 工具箱和属性窗口，请遵循以下步骤:

1. In the Solution Explorer window, double-click the Form1.cs node. This brings up the Form1 design tab in the main editing window. Locate the Toolbox tab to the left of the main editing window. Click the tab and the Toolbox window should expand, as shown in Figure 5-8. In the upper-right corner of the Toolbox, you should see the auto-hide icon, which looks like a thumbtack. Click the icon to turn off the auto-hide feature.

   

   图 5-8 。VS 工具箱

2. 在“工具箱”的“所有 Windows 窗体”节点下是一些控件，您可以将它们拖放到窗体上以构建 GUI。还有其他包含非图形组件的节点，这些组件有助于简化一些常见编程任务的创建和管理。例如，数据节点包含用于访问和管理数据存储的控件。向下滚动工具箱窗口，观察设计器公开的各种控件。

3. Under the All Windows Forms node, select the Label control. Move the cursor over the form; it should change to a crosshairs pointer. Draw a label on the form by clicking, dragging, and then releasing the mouse. In a similar fashion, draw a TextBox control and a Button control on the form. Figure 5-9 shows how the form should look.

   

   图 5-9 。示例表单布局

4. 通过单击工具箱窗口右上角的自动隐藏(图钉)图标，重新打开工具箱的自动隐藏功能。

5. 在“解决方案资源管理器”窗口下，找到主编辑窗口右侧的“属性”窗口。(您也可以在菜单步骤中选择查看属性窗口，打开属性窗口。)属性窗口显示设计视图中当前选定对象的属性。您还可以通过此窗口编辑对象的许多属性。

6. In the Form1 design window, click Label1. The Label1 control should be selected in the drop-down list at the top of the Properties window (see Figure 5-10). Locate the Text property and change it to “Enter your password:” (minus the quotes).

   

   图 5-10 。VS 属性窗口

   注意你可能需要重新排列表单上的控件才能看到所有的文本。

7. 将 TextBox1 的Password Char属性设置为*。将 Button1 的Text属性改为 OK。(单击窗体上的控件或使用“属性”窗口顶部的下拉列表来查看控件的属性。)

8. 通过选择文件全部保存来保存项目。

构建和执行汇编

要构建和执行程序集，请遵循以下步骤:

1. 在解决方案资源管理器中，双击 Form1 以打开设计窗口。

2. 在窗体设计器中，双击 Button1 控件。Form1 的代码编辑器将显示在主编辑窗口中。代码编辑器中添加了一个处理按钮单击事件的方法。

3. Add the following code to the method. This code will display the password entered in TextBox1 on the title bar of the form.

   private void button1_Click(object sender, EventArgs e)

   {

   this.Text = "Your password is " + textBox1.Text;

   }

4. Select Build Build Solution. The Output window shows the progress of compiling the assembly (see Figure 5-11). Once the assembly has been compiled, it is ready for execution. (If you can’t locate the Output window, select View menu Output.)

   

   图 5-11 。输出窗口中显示的生成进度

5. 选择调试开始调试。这将在调试模式下运行程序集。表单加载后，输入密码并单击 OK 按钮。您应该会在表单的标题栏中看到包含密码的消息。单击右上角的 x 关闭表单。

6. 选择文件保存全部，然后通过选择文件退出退出 VS。

活动 5-2。使用 VS 的调试特性

在本活动中，您将熟悉以下内容:

• 设置断点并单步执行代码
• 使用 VS IDE 中的各种调试窗口
• 使用错误列表窗口定位并修复构建错误

步进代码

若要逐句通过您的代码，请按照下列步骤操作:

1. 开始 VS .选择文件新建项目。

2. 在 C# Windows 模板下，选择控制台应用。将项目活动重命名为 5_2。

3. You will see a Program class file open in the code editor. The class file has a Main method that gets executed first when the application runs. Add the following code to the program class. This code contains a method that loads a list of numbers and displays the contents of the list in the console window.

   class Program

   {

   static List<int> numList = new List<int>();

   static void Main(string[] args)

   {

   LoadList(10);

   foreach (int i in numList)

   {

   Console.WriteLine(i);

   }

   Console.ReadLine();

   }

   static void LoadList(int iMax)

   {

   for (int i = 1; i <= iMax; i++)

   {

   numList.Add(i);

   }

   }

   }

4. To set a breakpoint (which pauses program execution), place the cursor on the declaration line of the Main method, right-click, and choose Breakpoint Insert Breakpoint. A red dot will appear in the left margin to indicate that a breakpoint has been set (see Figure 5-12).

   

   图 5-12 。在代码编辑器中设置断点

5. 选择调试开始调试。程序执行将在断点处暂停。黄色箭头表示将要执行的下一行代码。

6. Select View Toolbars and click the Debug toolbar. (A check next to the toolbar name indicates it is visible.) To step through the code one line at a time, select the Step Into button on the Debug toolbar (see Figure 5-13). (You can also press the F11 key.) Continue stepping through the code until you get to the LoadList.

   

   图 5-13 。使用调试工具栏

7. 逐句通过代码，直到for循环循环几次。此时，您可能对这段代码的运行感到满意，并且想要跳出这个方法。在“调试”工具栏上，单击“跳出”按钮。您应该返回到 Main 方法。

8. 继续遍历代码，直到for-each循环循环了几次。此时，您可能希望返回到运行时模式。为此，请单击“调试”工具栏上的“继续”按钮。当控制台窗口出现时，按 enter 键关闭窗口。

9. 再次以调试模式启动应用。单步执行代码，直到到达方法调用LoadList(10);。

10. 在“调试”工具栏上，选择“单步执行”按钮。这将执行该方法，并在执行返回到调用代码后重新进入中断模式。单步执行该方法后，继续单步执行几行代码，然后选择"调试"工具栏上的"停止"按钮。单击左边距中的红点以删除断点。

设置条件断点

要设置条件断点，请遵循以下步骤:

1. In the Program.cs file locate the LoadList method. Set a breakpoint on the following line of code:

   numList.Add(i);

2. Open the Breakpoints window by selecting Debug Windows Breakpoints. You should see the breakpoint you just set listed in the Breakpoints window (see Figure 5-14).

   

   图 5-14 。断点窗口

3. Right-click the breakpoint in the Breakpoints window and select Condition. You will see the Breakpoint Condition dialog box. Enter i == 3 as the condition expression and click the OK button (see Figure 5-15).

   

   图 5-15 。断点条件对话框

4. 选择调试开始。程序执行将暂停，您将看到一个黄色箭头，指示将执行的下一行。

5. Select Debug Windows Locals. The Locals window is displayed at the bottom of the screen (see Figure 5-16). The value of i is displayed in the Locals window. Verify that it is 3. Step through the code using the Debug toolbar and watch the value of i change in the Locals window. Click the Stop Debugging button in the Debug toolbar.

   

   图 5-16 。局部窗口

6. 在屏幕底部找到断点窗口。在“断点”窗口中右击断点，然后选择“条件”。通过清除“条件”复选框来清除当前条件，然后单击“确定”按钮。

7. 在“断点”窗口中右击断点，然后选择“命中次数”。将断点设置为命中次数等于 4 时中断，然后单击“确定”。

8. 选择调试开始。程序执行将暂停，黄色箭头指示将执行的下一行代码。

9. Right-click the numList statement and select Add Watch. A Watch window will be displayed with numList in it. Notice that numList is a System.Collections.Generics.List type. Click the plus sign next to numList. Verify that the list contains three items (see Figure 5-17). Step through the code and watch the array fill with items. Click the Stop button in the Debug toolbar.

   

   图 5-17 。观察窗

定位并修复构建错误

要定位并修复构建错误，请遵循以下步骤:

1. In the Program class, locate the following line of code and comment it out by placing a two slashes in front of it, as shown here:

   //static List<int> numList = new List<int>();

2. 注意代码中numList下面的红色曲线。这表明在应用运行之前必须修复一个生成错误。将鼠标悬停在该行上会显示关于错误的更多信息。

3. Select Build Build Solution. The Error List window will appear at the bottom of the screen, indicating a build error (see Figure 5-18).

   

   图 5-18 。使用“错误列表”窗口定位生成错误

4. 在"错误列表"窗口中双击包含生成错误的行。相应的代码将在代码编辑器中可见。

5. 通过删除斜线取消对步骤 1 中注释的行的注释。选择构建构建解决方案。这一次，输出窗口显示在屏幕的底部，表明没有构建错误。

6. 保存项目并退出 VS。

摘要

本章向您介绍了的基础知识 .NET 框架。您回顾了的一些基本目标 .NET 框架。你也看到了 .NET Framework 的结构以及 CLR 编译和执行代码的方式。这些概念都是相关且一致的 .NET 兼容的编程语言。此外，您还探索了 Visual Studio 集成开发环境的一些特性。虽然您不需要 IDE 来开发 .NET 应用，当涉及到生产力、调试和代码管理时，使用它是非常宝贵的。

使用 C# 可以开发许多类型的应用。这些应用包括使用 ASP.NET 的 Windows 桌面应用、使用 WPF 的 web 应用、使用 WinRT 的 Windows 应用商店应用以及使用 ASP.NET 或 WCF Web API 的应用服务应用。在以后的章节中，你将会看到这些技术，但是首先你需要学习如何使用 C# 编程。下一章是系列文章的第一章，着眼于 OOP 概念——比如类结构、继承和多态——是如何在 C# 代码中实现的。

六、创建类

在第五章中，你看了 .NET 框架的开发以及程序如何在框架下执行。那一章向您介绍了 Visual Studio IDE，并且您对使用它有了一些熟悉。您现在可以开始编码了！本章是向您介绍如何在 C# 中创建和使用类的系列文章的第一章。它涵盖了创建和使用类的基础知识。您将创建类，添加属性和方法，并在客户端代码中实例化这些类的对象实例。

阅读本章后，您应该熟悉以下内容:

• OOP 中使用的对象如何依赖于类定义文件
• 封装在面向对象程序设计中的重要作用
• 如何定义类的属性和方法
• 类构造函数的用途
• 如何在客户端代码中使用类的实例
• 重载类构造函数和方法的过程
• 如何用 Visual Studio 创建和测试类定义文件

引入对象和类

在 OOP 中，你在程序中使用对象来封装与程序所处理的实体相关的数据。例如，人力资源应用需要与雇员一起工作。员工具有需要跟踪的相关属性。您可能对员工姓名、地址、部门等感兴趣。虽然您跟踪所有员工的相同属性，但是每个员工都有这些属性的唯一值。在人力资源应用中，Employee对象获取并修改与雇员相关的属性。在面向对象的程序设计中，对象的属性被称为特性。

除了雇员的属性，人力资源应用还需要一组由Employee对象公开的既定行为。例如，人力资源部门感兴趣的一个员工行为是请求休假的能力。在 OOP 中，对象通过方法公开行为。对象包含一个封装实现代码的RequestTimeOff方法。

OOP 中使用的对象的属性和方法是通过类定义的。类是一个蓝图，它定义了作为类的实例创建的对象的属性和行为。如果您已经完成了应用的正确分析和设计，那么您应该能够参考 UML 设计文档来确定需要构造哪些类以及这些类将包含哪些属性和方法。UML 类图包含了构建系统类所需的初始信息。

为了演示使用 C# 构建一个类，您将看到一个简单的Employee类的代码。Employee类将拥有封装和处理雇员数据的属性和方法，作为虚构的人力资源应用的一部分。

定义类别

让我们检查创建类定义所需的源代码。第一行代码将代码块定义为一个类定义，使用关键字class后跟类名。类定义的主体由一个左右花括号括起来。代码块的结构如下:

class Employee
{
}

创建类属性

定义了类代码块的起点和终点之后，下一步是定义类中包含的实例变量(通常称为字段)。这些变量保存类的实例将操作的数据。关键字private确保这些实例变量只能由类内部的代码操作。以下是实例变量定义:

private int _empID;
private string _loginName;
private string _password;
private string _department;
private string _name;

当该类(客户端代码)的用户需要查询或设置这些实例变量的值时，公共属性会向它们公开。在代码的属性块中有一个Get块和一个Set块。Get块将私有实例变量的值返回给该类的用户。这段代码提供了一个可读的属性。Set块提供写使能属性；它将客户端代码发送的值传递给相应的私有实例变量。下面是一个属性块的示例:

public string Name
{
    get { return _name; }
    set { _name = value; }
}

有时，您可能希望限制对属性的访问，以便客户端代码可以读取属性值，但不能更改它。通过删除属性块中的set块，您创建了一个只读属性。以下代码显示了如何将EmployeeID属性设为只读:

public int EmployeeID
{
    get { return _empID; }
}

注意私有和公共关键字影响代码的范围。有关范围的更多信息，请参见附录 a。

OOP 的新手经常会问，为什么有必要做这么多工作来获取和设置属性。难道不能创建用户可以直接读写的公共实例变量吗？答案在于 OOP 的基本原则之一:封装。封装意味着客户端代码不能直接访问数据。当处理数据时，客户端代码必须使用通过类的实例访问的明确定义的属性和方法。以下是以这种方式封装数据的一些好处:

• 防止对数据的未授权访问
• 通过错误检查确保数据完整性
• 创建只读或只写属性
• 将类的用户与实现代码中的更改隔离开来

例如，您可以通过以下代码检查以确保密码至少有六个字符长:

public string Password
{
    get { return _password; }
    set
    {
        if (value.Length >= 6)
        {
            _password = value;
        }
        else
        {
            throw new Exception("Password must be at least 6 characters");
        }
    }
}

创建类方法

类方法定义了类的行为。例如，下面为Employee类定义了一个验证雇员登录的方法:

public Boolean Login(string loginName, string password)
{
    if (loginName == "Jones" & password == "mj")
    {
        _empID = 1;
        Department = "HR";
        Name = "Mary Jones";
        return true;
    }
    else if (loginName == "Smith" & password == "js")
    {
        _empID = 2;
        Department = "IS";
        Name = "Jerry Smith";
        return true;
    }
    else
    {
        return false;
    }
}

当客户端代码调用该类的Login方法时，登录名和密码被传递给该方法(这些被称为输入参数)。检查参数。如果它们匹配一个当前的雇员，那么该类的实例将被该雇员的属性填充，一个布尔值true将被传递回调用代码。如果登录名和密码与当前雇员不匹配，一个布尔值false被传递回客户端代码。return关键字用于将控制权返回给具有指定值的客户端代码。

在前面的方法中，一个值被返回给客户端代码。这由 Boolean 关键字指示，该关键字将布尔值类型分配给返回值。下面的AddEmployee方法是Employee类的另一个方法。当一个雇员需要被添加到数据库中时，它被调用，并将新分配的雇员 ID(作为整数类型)返回给客户机。该方法还用新添加的雇员的属性填充了Employee类的对象实例。

public int AddEmployee(string loginName, string password,
            string department, string name)
{
    //Data normally saved to database.
    _empID = 3;
    LoginName = loginName;
    Password = password;
    Department = department;
    Name = name;
    return EmployeeID;
}

并非所有方法都向客户端返回值。在这种情况下，该方法用 void 关键字声明，以指示没有返回值。下面的方法更新密码，但不向客户端返回值。

public void UpdatePassword(string password)
{
    //Data normally saved to database.
    Password = password;
}

活动 6-1。创建雇员类

在本活动中，您将熟悉以下内容:

• 如何使用 Visual Studio 创建 C# 类定义文件
• 如何从客户端代码创建和使用类的实例

注意如果您还没有下载启动文件，请下载。有关说明，请参见附录 C。本实验是一个 Windows 窗体应用，它是可以用 Visual Studio 构建的 Windows 客户端类型应用之一。

定义员工类别

要创建 Employee 类，请遵循以下步骤:

1. 启动 Visual Studio。选择文件打开项目。

2. 导航到 Activity6_1Starter 文件夹，单击Activity6_1.sln文件，然后单击 Open。当项目打开时，它将包含一个登录表单。稍后您将使用这个表单来测试您创建的Employee类。

3. Select Project Add Class. In the Add New Item dialog box, rename the class file to Employee.cs, and then click Add. Visual Studio adds the Employee.cs file to the project and adds the following class definition code to the file (along with the name space definition and some using declarations.):

   class Employee

   {

   }

4. Enter the following code between the opening and closing brackets to add the private instance variables to the class body in the definition file:

   private int _empID;

   private string _loginName;

   private string _password;

   private int _securityLevel;

5. Next, add the following public properties to access the private instance variables defined in step 4:

   public int EmployeeID

   {

   get { return _empID; }

   }

   public string LoginName

   {

   get { return _loginName; }

   set { _loginName = value; }

   }

   public string Password

   {

   get { return _password; }

   set { _password = value; }

   }

   public int SecurityLevel

   {

   get { return _securityLevel; }

   }

6. After the properties, add the following Login method to the class definition:

   public Boolean Login(string loginName, string password)

   {

   LoginName = loginName;

   Password = password;

   //Data nomally retrieved from database.

   //Hard coded for demo only.

   if (loginName == "Smith" & password == "js")

   {

   _empID = 1;

   _securityLevel = 2;

   return true;

   }

   else if (loginName == "Jones" & password == "mj")

   {

   _empID = 2;

   _securityLevel = 4;

   return true;

   }

   else

   {

   return false;

   }

   }

7. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

测试雇员类

要测试Employee类，请遵循以下步骤:

1. Open frmLogin in the code editor and locate the btnLogin click event code.

   提示双击表单设计器中的登录按钮也会在代码编辑器中调出事件代码。

2. In the body of the btnLogin click event, declare and instantiate a variable of type Employee called oEmployee:

   Employee = new Employee()；

3. Next, call the Login method of the oEmployee object, passing in the values of the login name and the password from the text boxes on the form. Capture the return value in a Boolean variable called bResult:

   Boolean bResult = oEmployee.Login(txtName.Text,txtPassword.Text);

4. After calling the Login method, if the result is true, show a message box stating the user’s security level, which is retrieved by reading the SecurityLevel property of the oEmployee object. If the result is false, show a login failed message.

   If (bResult == true)

   {

   MessageBox.Show("Your security level is " + oEmployee.SecurityLevel);

   }

   else

   {

   MessageBox.Show("Login Failed");

   }

5. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

6. 选择调试开始运行项目。通过输入登录名 Smith 和密码 js 来测试登录表单。您应该会收到一条消息，指示安全级别为 2。尝试输入您的姓名和密码 pass。您应该会收到一条消息，表明登录失败。

7. 测试登录过程后，关闭表单；这将停止调试器。

注意本章代码对无效登录使用异常。这只是为了演示的目的。抛出错误是一个开销很大的过程，不应该用于业务处理逻辑。有关正确使用抛出错误的更多信息，请参见附录 b。

使用构造函数

在 OOP 中，当类的对象实例被实例化时，使用构造函数来执行任何需要发生的处理。例如，您可以初始化对象实例的属性或建立数据库连接。类构造器方法的命名与类相同。当类的对象实例被客户端代码实例化时，将执行构造函数方法。下面的构造函数在Employee类中用来初始化Employee类的对象实例的属性。将雇员 ID 传递给构造函数，以便从数据存储中检索值，如下所示:

public Employee(int empID)
{
    //Retrieval of data hardcoded for demo
    if (empID == 1)
    {
        _empID = 1;
        LoginName = "Smith";
        Password = "js";
        Department = "IT";
        Name = "Jerry Smith";

    }
    else if (empID == 2)
    {
        _empID = 2;
        LoginName = "Jones";
        Password = "mj";
        Department = "HR";
        Name = "Mary Jones";
    }
    else
    {
        throw new Exception("Invalid EmployeeID");
    }
}

重载方法

重载方法的能力是 OOP 语言的一个有用的特性。通过定义多个同名但包含不同签名的方法，可以重载一个类中的方法。方法签名是方法名及其参数类型列表的组合。如果更改参数类型列表，则创建不同的方法签名。例如，参数类型列表可以包含不同数量的参数或不同的参数类型。编译器将通过检查客户端传入的参数类型列表来确定执行哪个方法。

注意改变参数的传递方式(换句话说，从byVal到byRef)不会改变方法签名。改变方法的返回类型也不会创建唯一的方法签名。有关方法签名和传递参数的更详细讨论，请参考附录 a。

假设您想提供Employee类的两个方法，这两个方法将允许您向数据库中添加雇员。第一种方法是在添加员工时为员工分配用户名和密码。第二种方法添加雇员信息，但是将用户名和密码的分配推迟到以后。您可以通过重载Employee类的AddEmployee方法来轻松实现这一点，如以下代码所示:

public int AddEmployee(string loginName, string password,
           string department, string name)
{
    //Data normally saved to database.
    _empID = 3;
    LoginName = loginName;
    Password = password;
    Department = department;
    Name = name;
    return EmployeeID;
}

public int AddEmployee(string department, string name)
{
    //Data normally saved to database.
    _empID = 3;
    Department = department;
    Name = name;
    return EmployeeID;
}

因为第一个方法(string，string，string，string)的参数类型列表与第二个方法(string，string)的参数类型列表不同，所以编译器可以确定调用哪个方法。OOP 中一个常见的技术是重载类的构造函数。例如，当创建一个Employee类的实例时，一个构造函数可以用于新雇员，另一个可以用于当前雇员，方法是在客户机实例化类实例时传入雇员 ID。下面的代码显示了类构造函数的重载:

public Employee()
{
    _empID = -1;
}

public Employee(int empID)
{
    //Retrieval of data hard coded for demo
    if (empID == 1)
    {
        _empID = 1;
        LoginName = "Smith";
        Password = "js";
        Department = "IT";
        Name = "Jerry Smith";

    }
    else if (empID == 2)
    {
        _empID = 2;
        LoginName = "Jones";
        Password = "mj";
        Department = "HR";
        Name = "Mary Jones";
    }
    else
    {
        throw new Exception("Invalid EmployeeID");
    }
}

活动 6-2。创建构造函数和重载方法

在本活动中，您将熟悉以下内容:

• 如何创建和重载类构造函数方法
• 如何从客户端代码中使用类的重载构造函数
• 如何控制一个类的方法
• 如何从客户端代码中使用类的重载方法

创建和重载类构造函数

要创建和重载类构造函数，请遵循以下步骤:

1. 启动 Visual Studio。选择文件打开项目。

2. 导航到 Activity6_2Starter 文件夹，单击 Activity6_2.sln 文件，然后单击“打开”。当项目打开时，它将包含一个 frmEmployeeInfo 表单，您将使用它来测试Employee类。该项目还包括Employee.cs文件，其中包含了Employee类定义代码。

3. 在代码编辑器中打开 Employee.cs 并检查代码。该类包含几个需要维护的与雇员相关的属性。

4. After the property declaration code, add the following private method to the class. This method simulates the generation of a new employee ID.

   private int GetNextID()

   {

   //simulates the retrieval of next

   //available id from database

   return 100;

   }

5. Create a default class constructor, and add code that calls the GetNextID method and assigns the return value to the private instance variable _empID:

   public Employee()

   {

   _empID = GetNextID();

   }

6. Overload the default constructor method by adding a second constructor method that takes an integer parameter of empID, like so:

   public Employee(int empID)

   {

   //Constructor for existing employee

   }

7. Add the following code to the overloaded constructor, which simulates extracting the employee data from a database and assigns the data to the instance properties of the class:

   //Simulates retrieval from database

   if (empID == 1)

   {

   _empID = empID;

   LoginName = "smith";

   PassWord = "js";

   SSN = 123456789;

   Department = "IS";

   }

   else if (empID == 2)

   {

   _empID = empID;

   LoginName = "jones";

   PassWord = "mj";

   SSN = 987654321;

   Department = "HR";

   }

   else

   {

   throw new Exception("Invalid Employee ID");

   }

8. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

测试雇员类构造函数

要测试Employee类构造函数，请遵循以下步骤:

1. 在窗体编辑器中打开 EmployeeInfoForm，双击“新雇员”按钮，在代码编辑器中调出 click 事件代码。

2. In the click event method body, declare and instantiate a variable of type Employee called oEmployee:

   Employee oEmployee = new Employee();

3. Next, update the employeeID text box with the employee ID, disable the employee ID text box, and clear the remaining textboxes:

   txtEmpID.Text = oEmployee.EmpID.ToString();

   txtEmpID.Enabled = false;

   txtLoginName.Text = "";

   txtPassword.Text = "";

   txtSSN.Text = "";

   txtDepartment.Text = "";

4. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

5. 在窗体编辑器中打开 EmployeeInfoForm，双击现有雇员按钮，在代码编辑器中调出 click 事件代码。

6. In the click event method body, declare and instantiate a variable of type Employee called oEmployee. Retrieve the employee ID from the txtEmpID text box and pass it as an argument in the constructor. The int.Parse method converts the text to an integer data type:

   Employee oEmployee = new Employee(int.Parse(txtEmpID.Text));

7. Next, disable the employee ID textbox and fill in the remaining text boxes with the values of the Employee object’s properties:

   txtEmpID.Enabled = false;

   txtLoginName.Text = oEmployee.LoginName;

   txtPassword.Text = oEmployee.PassWord;

   txtSSN.Text = oEmployee.SSN.ToString();

   txtDepartment.Text = oEmployee.Department;

8. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

9. 选择 Debug Start 运行项目并测试代码。

10. 当显示 EmployeeInfo 窗体时，单击“新建雇员”按钮。您应该看到在雇员 ID 文本框中已经生成了一个新的雇员 ID。

11. 单击重置按钮清除并启用员工 ID 文本框。

12. 为员工 ID 输入值 1，然后单击现有员工按钮。该员工的信息显示在表单上。

13. 测试完构造函数后，关闭窗体，这将停止调试器。

重载一个类方法

要重载一个类方法，请遵循以下步骤:

1. 在代码编辑器中打开 Employee.cs 代码。

2. Add the following Update method to the Employee class. This method simulates the updating of the employee security information to a database:

   public string Update(string loginName, string password)

   {

   LoginName = loginName;

   PassWord = password;

   return "Security info updated.";

   }

3. Add a second Update method to simulate the updating of the employee human resources data to a database:

   public string Update(int ssNumber, string department)

   {

   SSN = ssNumber;

   Department = department;

   return "HR info updated.";

   }

4. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

测试重载更新方法

要测试重载的Update方法，请遵循以下步骤:

1. 在窗体编辑器中打开 EmployeeInfo 窗体，双击“更新 SI”按钮。在代码编辑器窗口中，您将看到 click 事件代码。

2. In the click event method, declare and instantiate a variable of type Employee called oEmployee. Retrieve the employee ID from the txtEmpID text box and pass it as an argument in the constructor:

   Employee oEmployee = new Employee(int.Parse(txtEmpID.Text));

3. Next, call the Update method, passing the values of the login name and password from the text boxes. Show the method return message to the user in a message box:

   MessageBox.Show(oEmployee.Update(txtLoginName.Text, txtPassword.Text));

4. Update the login name and password text boxes with the property values of the Employee object:

   txtLoginName.Text = oEmployee.LoginName;

   txtPassword.Text = oEmployee.PassWord;

5. Repeat this process to add similar code to the Update HR button click event method to simulate updating the human resources information. Add the following code to the click event method:

   Employee oEmployee = new Employee(int.Parse(txtEmpID.Text));

   MessageBox.Show(oEmployee.Update(int.Parse(txtSSN.Text), txtDepartment.Text));

   txtSSN.Text = oEmployee.SSN.ToString();

   txtDepartment.Text = oEmployee.Department;

6. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

7. 选择 Debug Start 运行项目并测试代码。

8. 为员工 ID 输入值 1，然后单击现有员工按钮。

9. 更改安全信息的值，然后单击“更新”按钮。

10. 更改人力资源信息的值，然后单击“更新”按钮。

11. 您应该看到正确的Update方法是根据传递给它的参数调用的。测试完Update方法后，关闭表单。

摘要

本章为你在 C# 代码中创建和使用类打下了坚实的基础。既然您已经熟悉了构造和使用类，那么您就可以开始研究实现 OOP 的一些更高级的特性了。在第七章中，你将专注于继承和多态是如何在 C# 代码中实现的。作为一名面向对象的程序员，熟悉这些概念并学习如何在程序中实现它们是很重要的。

七、创建类层次结构

在第六章中，您学习了如何创建类、添加属性和方法，以及在客户端代码中实例化类的对象实例。本章介绍了继承和多态的概念。

继承是任何 OOP 语言最强大和最基本的特性之一。使用继承，您可以创建封装通用功能的基类。其他类可以从这些基类派生。派生类继承基类的属性和方法，并根据需要扩展功能。

第二个基本的 OOP 特性是多态。多态让基类定义必须由任何派生类实现的方法。基类定义了派生类必须遵守的消息签名，但是方法的实现代码留给了派生类。多态的强大之处在于，客户知道他们可以用同样的方式实现基类的方法。即使方法的内部处理可能不同，客户端也知道方法的输入和输出是相同的。

阅读本章后，您将了解以下内容:

• 如何创建和使用基类
• 如何创建和使用派生类
• 访问修饰符如何控制继承
• 如何覆盖基类方法
• 如何实现接口
• 如何通过继承和接口实现多态

理解继承

任何 OOP 语言最强大的特性之一就是继承。继承是创建基类的能力，该基类具有可在从基类派生的类中使用的属性和方法。

创建基类和派生类

继承的目的是创建一个基类，它封装了相同类型的派生类可以使用的属性和方法。例如，您可以创建一个基类Account。在Account类中定义了一个GetBalance方法。然后，您可以创建两个单独的类:SavingsAccount和CheckingAccount。因为SavingsAccount类和CheckingAccount类使用相同的逻辑来检索余额信息，所以它们从基类Account继承了GetBalance方法。这使您能够创建一个更易于维护和管理的通用代码库。

然而，派生类不限于基类的属性和方法。派生类可能需要额外的方法和属性，这些方法和属性是它们所特有的。例如，从支票账户提款的业务规则可能要求维持最低余额。然而，从储蓄账户提款可能不需要最低余额。在这个场景中，派生的CheckingAccount和SavingsAccount类都需要它们自己对Withdraw方法的唯一定义。

要在 C# 中创建一个派生类，需要输入类名，后跟一个冒号(:)和基类名。以下代码演示了如何创建一个从Account基类派生的CheckingAccount类:

class Account
{
    long _accountNumber;

    public long AccountNumber
    {
        get { return _accountNumber; }
        set { _accountNumber = value; }
    }
    public double GetBalance()
    {
        //code to retrieve account balance from database
        return (double)10000;
    }
}

class CheckingAccount : Account
{
    double _minBalance;

    public double MinBalance
    {
        get { return _minBalance; }
        set { _minBalance = value; }
    }
    public void Withdraw(double amount)
    {
        //code to withdraw from account
    }
}

下面的代码可以由创建一个对象实例CheckingAccount的客户端实现。注意，客户端感觉不到对GetBalance方法的调用和对Withdraw方法的调用之间的区别。在这种情况下，客户端不知道Account类；相反，这两种方法似乎都是由CheckingAccount定义的。

CheckingAccount oCheckingAccount = new CheckingAccount();
double balance;
oCheckingAccount.AccountNumber = 1000;
balance = oCheckingAccount.GetBalance();
oCheckingAccount.Withdraw(500);

创建密封类

默认情况下，任何 C# 类都可以被继承。当创建可以被继承的类时，你必须小心不要以这样的方式修改它们，以至于派生类不再像预期的那样工作。如果不小心，您可能会创建难以管理和调试的复杂继承链。例如，假设您基于Account类创建了一个派生的CheckingAccount类。另一个程序员可以基于CheckingAccount创建一个派生类，并以你从未想过的方式使用它。(这很容易发生在沟通和设计方法不佳的大型编程团队中。)

通过使用sealed修饰符，您可以创建您知道不会从其派生的类。这种类型的班级通常被称为密封或最终班级。通过使一个类不可继承，可以避免与修改基类代码相关的复杂性和开销。下面的代码演示了在构造类定义时如何使用sealed修饰符:

sealed class CheckingAccount : Account

创建抽象类

在这个例子中，客户端可以通过派生的CheckingAccount类的实例或者直接通过基类Account的实例来访问GetBalance方法。有时，你可能想要一个不能被客户端代码实例化的基类。必须通过派生类来访问该类的方法和属性。在这种情况下，您使用abstract修饰符来构造基类。以下代码显示了带有abstract修饰符的Account类定义:

abstract class Account

这使得Account类成为一个抽象类。为了让客户端能够访问GetBalance方法，它们必须创建一个派生的CheckingAccount类的实例。

在基类中使用访问修饰符

当使用继承设置类层次结构时，必须管理如何访问类的属性和方法。到目前为止，你看到的两个访问修饰符是 public 和 private。如果基类的方法或属性被公开为 public，则派生类和派生类的任何客户端都可以访问它。如果将基类的属性或方法公开为私有，则派生类或客户端不能直接访问它。

您可能希望向派生类公开基类的属性或方法，而不是向派生类的客户端公开。在这种情况下，使用受保护的访问修饰符。下面的代码演示了 protected 访问修饰符的用法:

protected double GetBalance()
{
    //code to retrieve account balance from database
    return (double)10000;
}

通过将GetBalance方法定义为受保护的，它可以被派生类CheckingAccount访问，但是不能被访问CheckingAccount类实例的客户端代码访问。

活动 7-1。使用基类和派生类实现继承 NCE

在本活动中，您将熟悉以下内容:

• 创建基类和继承其方法的派生类
• 使用受保护的访问修饰符来限制基类方法的使用
• 创建抽象基类

创建基类和派生类

要创建Account类，请遵循以下步骤:

1. 启动 Visual Studio。选择文件打开项目。

2. 导航到 Activity7_1Starter 文件夹，单击 Activity7_1.sln 文件，然后单击“打开”。当项目打开时，它将包含一个出纳员表单。稍后您将使用这个表单来测试您创建的类。

3. 在“解决方案资源管理器”窗口中，右键单击项目节点并选择“添加类”。

4. 在“添加新项”对话框中，将类文件重命名为 Account.cs，然后单击“打开”。Account.cs 文件被添加到项目中，Account类定义代码被添加到该文件中。

5. Add the following code to the class definition file to create the private instance variable (private is the default modifier for instance variables):

   int _accountNumber;

6. Add the following GetBalance method to the class definition:

   public double GetBalance(int accountNumber)

   {

   _accountNumber = accountNumber;

   //Data normally retrieved from database.

   if (_accountNumber == 1)

   {

   return 1000;

   }

   else if (_accountNumber == 2)

   {

   return 2000;

   }

   else

   {

   return -1; //Account number is incorrect

   }

   }

7. After the Account class, add the following code to create the CheckingAccount and SavingsAccount derived classes:

   class CheckingAccount : Account

   {

   }

   class SavingsAccount : Account

   {

   }

8. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

测试类别

要测试这些类，请遵循以下步骤:

1. 在代码编辑器中打开柜员表单，找到btnGetBalance点击事件代码。

2. Inside the event procedure, prior to the try block, declare and instantiate a variable of type CheckingAccount called oCheckingAccount, a variable of type SavingsAccount called oSavingsAccount, and a variable of type Account called oAccount:

   CheckingAccount oCheckingAccount = new CheckingAccount();

   SavingsAccount oSavingsAccount = new SavingsAccount();

   Account oAccount = new Account();

3. Depending on which radio button is selected, call the GetBalance method of the appropriate object and pass the account number value from the AccountNumber text box. Show the return value in the Balance text box. Place the following code in the try block prior to the catch statement:

   if (rdbChecking.Checked)

   {

   txtBalance.Text =

   oCheckingAccount.GetBalance(int.Parse(txtAccountNumber.Text)).ToString();

   }

   else if (rdbSavings.Checked)

   {

   txtBalance.Text =

   oSavingsAccount.GetBalance(int.Parse(txtAccountNumber.Text)).ToString();

   }

   else if (rdbGeneral.Checked)

   {

   txtBalance.Text =

   oAccount.GetBalance(int.Parse(txtAccountNumber.Text)).ToString();

   }

4. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

5. 选择调试开始运行项目。输入账号 1，并单击支票账户类型的获取余额按钮。你应该得到 1000 英镑的余额。测试其他帐户类型。您应该得到相同的结果，因为所有的类都在使用基类中定义的相同的GetBalance函数。

6. 测试后，关闭窗体，这将停止调试器。

将基类方法的使用限制在其派生类中

此时，基类的GetBalance方法是公共的，这意味着它可以被派生类及其客户端访问。让我们改变这一点，使GetBalance方法只能被派生类单独访问，而不能被它们的客户端访问。要以这种方式保护GetBalance方法，请遵循以下步骤:

1. 找到Account类的GetBalance方法。

2. 将GetBalance方法的访问修饰符从public改为protected。

3. 切换到 frmTeller 代码编辑器，找到btnGetBalance click 事件代码。

4. 将光标悬停在对oCheckingAccount对象的GetBalance方法的调用上。您将看到一条警告，指出它是一个受保护的函数，在此上下文中不可访问。

5. 注释掉try和catch语句之间的代码。

6. 切换到 Account.cs 代码编辑器。

7. Add the following code to create the following private instance variable to the SavingsAccount class definition file:

   double _dblBalance;

8. Add the following Withdraw method to the SavingsAccount class. This function calls the protected method of the Account base class:

   public double Withdraw(int accountNumber, double amount)

   {

   _dblBalance = GetBalance(accountNumber);

   if (_dblBalance >= amount)

   {

   _dblBalance - = amount;

   return _dblBalance;

   }

   else

   {

   Return -1; //Not enough funds

   }

   }

9. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

测试受保护的基类方法

要测试Withdraw方法，请遵循以下步骤:

1. 在代码编辑器中打开 frmTeller 表单，找到btnWithdraw click 事件代码。

2. Inside the event procedure, prior to the try block, declare and instantiate a variable of type SavingsAccount called oSavingsAccount.

   SavingsAccount oSavingsAccount = new SavingsAccount();

3. Call the Withdraw method of the oSavingsAccount. Pass the account number value from the AccountNumber text box and the withdrawal amount from the Amount text box. Show the return value in the Balance text box. Place the following code in the try block prior to the catch statement:

   txtBalance.Text = oSavingsAccount.Withdraw

   (int.Parse(txtAccountNumber.Text),double.Parse(txtAmount.Text)).ToString();

4. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

5. 选择调试开始运行项目。

6. 通过输入账号 1 和取款金额 200 来测试SavingsAccount类的Withdraw方法。点击撤销按钮。您应该会得到 800 英镑的余额。

7. 输入账号 1，取款金额 2000。点击撤销按钮。您应该得到-1，表示资金不足。

8. 测试完Withdraw方法后，关闭表单，这将停止调试器。

将基类的所有成员限制在其派生类中使用

因为Account基类是公共的，所以它可以被派生类的客户端实例化。您可以通过使Account基类成为抽象类来改变这一点。抽象类只能被它的派生类访问，不能被它们的客户端实例化和访问。要创建并测试抽象类的可访问性，请遵循以下步骤:

1. 在 Account.cs 代码中找到Account类定义。

2. Add the abstract keyword to the class definition code, like so:

   abstract class Account

3. Select Build Build Solution. You should receive a build error in the Error List window. Find the line of code causing the error.

   Account oAccount = new Account();

4. 注释掉该行代码，然后再次选择 Build Build Solution。它现在应该没有任何错误。

5. 保存并关闭项目。

重写基类的方法

当派生类从基类继承方法时，它继承该方法的实现。作为基类的设计者，您可能希望让派生类以自己独特的方式实现该方法。这就是所谓的重写基类方法。

默认情况下，派生类不能覆盖其基类的实现代码。要允许覆盖基类方法，必须在方法定义中包含关键字virtual。在派生类中，使用相同的方法签名定义一个方法，并使用override关键字指示它正在重写一个基类方法。下面的代码演示了在Account基类中创建一个可重写的Deposit方法:

public virtual  void Deposit(double amount)
{
    //Base class implementation
}

要覆盖派生的CheckingAccount类中的Deposit方法，请使用以下代码:

public override void Deposit(double amount)
{
    //Derived class implementation
}

需要注意的一个场景是当一个派生类从基类继承，第二个派生类从第一个派生类继承。当一个方法重写基类中的一个方法时，它在默认情况下变成可重写的。为了限制重写方法在继承链上被重写，您必须在派生类的方法定义中在override关键字之前包含sealed关键字。如果CheckingAccount类派生自,CheckingAccount类中的以下代码防止覆盖Deposit方法:

public sealed override void Deposit(double amount)
{
    //Derived class implementation
}

当您指示基类方法是可重写的时，派生类可以选择重写该方法或使用基类提供的实现。在某些情况下，您可能希望使用基类方法作为派生类的模板。基类没有实现代码，但用于定义派生类中使用的方法签名。这种类型的类被称为抽象基类。你用抽象关键字定义类和方法。以下代码用于通过抽象Deposit方法创建抽象Account基类:

public abstract class Account
{
    public abstract void Deposit(double amount);
}

注意，因为在基类中没有为Deposit方法定义实现代码，所以省略了方法体。

从基类调用派生类方法

可能会出现这样的情况:从基类的另一个方法调用基类中可重写的方法，而派生类重写基类的方法。当从派生类的实例调用基类方法时，基类将调用派生类的重写方法。下面的代码显示了这种情况的一个例子。一个CheckingAccount基类包含一个可重写的GetMinBalance方法。从CheckingAccount类继承而来的InterestBearingCheckingAccount类覆盖了GetMinBalance方法。

class CheckingAccount
{
    private double _balance = 2000;

    public double Balance
    {
        get { return _balance; }
    }
    public virtual double GetMinBalance()
    {
        return 200;
    }
    public virtual void Withdraw(double amount)
    {
        double minBalance = GetMinBalance();
        if (minBalance < (Balance - amount))
        {
            _balance -= amount;
        }
        else
        {
            throw new Exception("Minimum balance error.");
        }
    }
}
class InterestBearingCheckingAccount : CheckingAccount
{
    public override double GetMinBalance()
    {
        return 1000;
    }
}

客户端创建了一个InterestBearingCheckingAccount类的对象实例，并调用了Withdraw方法。在这种情况下，执行InterestBearingCheckingAccount类的被覆盖的GetMinimumBalance方法，并使用最小余额 1000。

InterestBearingCheckingAccount oAccount = new InterestBearingCheckingAccount();
oAccount.Withdraw(500);

当调用Withdraw方法时，您可以在它前面加上this限定符:

double minBalance = this.GetMinBalance();

因为如果没有使用限定符，那么this限定符就是默认的限定符，所以代码的执行方式和前面演示的一样。执行该方法的最大派生类实现(已实例化)。换句话说，如果客户端实例化了一个InterestBearingCheckingAccount类的实例，如前所述，基类对GetMinimumBalance的调用是针对派生类的实现的。另一方面，如果客户创建了一个CheckingAccount类的实例，基类对GetMinimumBalance的调用是针对它自己的实现的。

从派生类中调用基类方法

在某些情况下，您可能希望开发一个派生类方法，该方法仍然使用基类中的实现代码，但也用自己的实现代码来扩充它。在这种情况下，您在派生类中创建一个重写方法，并使用base限定符调用基类中的代码。下面的代码演示了base限定符的用法:

public override void Deposit(double amount)
{
    base.Deposit(amount);
    //Derived class implementation.
}

基类的重载方法

派生类继承的方法可以被重载。重载类的方法签名必须使用与重载方法相同的名称，但参数列表必须不同。这与重载同一类的方法是一样的。下面的代码演示派生方法的重载:

class CheckingAccount
{
    public void Withdraw(double amount)
    {
    }
}
class InterestBearingCheckingAccount : CheckingAccount
{
    public void Withdraw(double amount, double minBalance)
    {
    }
}

实例化InterestBearingCheckingAccount实例的客户端代码可以访问两个Withdraw方法。

InterestBearingCheckingAccount oAccount = new InterestBearingCheckingAccount();
oAccount.Withdraw(500);
oAccount.Withdraw(500, 200);

隐藏基类方法

如果派生类中的方法与基类方法具有相同的方法签名，但是没有用关键字override、标记，那么它实际上隐藏了基类的方法。虽然这可能是有意的行为，但有时它可能会在无意中发生。虽然代码仍然可以编译，但是 IDE 会发出警告，询问这是否是预期的行为。如果您打算隐藏基类方法，您应该在派生类的方法定义中显式使用new关键字。使用new关键字将向 IDE 表明这是预期的行为，并消除警告。下面的代码演示隐藏基类方法:

class CheckingAccount
{
    public virtual void Withdraw(double amount)
    {
    }
}

class InterestBearingCheckingAccount : CheckingAccount
{
    public new void Withdraw(double amount)
    {
    }
    public void Withdraw(double amount, double minBalance)
    {
    }
}

活动 7-2。重写基类方法

在本活动中，您将熟悉以下内容:

• 覆盖基类的方法
• 在派生类中使用基限定符

覆盖基类方法

要覆盖Account类，请遵循以下步骤:

1. 开始 VS .选择文件打开项目。

2. 导航到 Activity7_2Starter 文件夹，单击 Activity7_2.sln 文件，然后单击“打开”。当项目打开时，它将包含一个出纳员表单。稍后您将使用这个表单来测试您将创建的类。该项目还包含一个 BankClasses.cs 文件。这个文件包含了基类Account和派生类SavingsAccount和CheckingAccount的代码。

3. 检查基类Account中定义的Withdraw方法。该方法检查帐户中是否有足够的资金，如果有，则更新余额。您将在CheckingAccount类中覆盖这个方法，以确保维持最小的平衡。

4. Change the Withdraw method definition in the Account class to indicate it is overridable, like so:

   public virtual double Withdraw(double amount)

5. Add the following GetMinimumBalance method to the CheckingAccount class definition:

   public double GetMinimumBalance()

   {

   return 200;

   }

6. Add the following overriding Withdraw method to the CheckingAccount class definition. This method adds a check to see that the minimum balance is maintained after a withdrawal.

   public override double Withdraw(double amount)

   {

   if (Balance >= amount + GetMinimumBalance())

   {

   _balance - = amount;

   return Balance;

   }

   else

   {

   return -1; //Not enough funds

   }

   }

7. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

测试被覆盖的方法

要测试您已经创建的修改过的Withdraw方法，请遵循以下步骤:

1. 在代码编辑器中打开 frmTeller 表单，找到btnWithdraw click 事件代码。

2. Depending on which radio button is selected, call the Withdraw method of the appropriate object and pass the value of the txtAmount text box. Add the following code in the try block to show the return value in the txtBalance text box:

   if (rdbChecking.Checked)

   {

   oCheckingAccount.AccountNumber = int.Parse(txtAccountNumber.Text);

   txtBalance.Text = oCheckingAccount.Withdraw(double.Parse(txtAmount.Text)).ToString();

   }

   else if (rdbSavings.Checked)

   {

   oSavingsAccount.AccountNumber = int.Parse(txtAccountNumber.Text);

   txtBalance.Text = oSavingsAccount.Withdraw(double.Parse(txtAmount.Text)).ToString();

   }

3. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

4. 选择调试开始运行项目。

5. 输入帐号 1，选择“检查”选项按钮，然后单击“获取余额”按钮。你应该得到 1000 英镑的余额。

6. 输入取款金额 200，然后单击取款按钮。您应该会得到 800 英镑的余额。

7. 输入取款金额 700，然后点击取款按钮。您应该得到-1(表示资金不足),因为最终余额将小于最小余额 200。

8. 输入帐号 1，选择“储蓄”选项按钮，然后单击“获取余额”按钮。你应该得到 1000 英镑的余额。

9. 输入取款金额 600，然后点击取款按钮。您应该会得到 400 英镑的余额。

10. 输入取款金额 400，然后点击取款按钮。您应该得到一个 0 的结果余额，因为对于使用Account基类的Withdraw方法的储蓄帐户，没有最小余额。

11. 测试后，关闭窗体，这将停止调试器。

使用基本限定符调用基类方法

此时，CheckingAccount类的Withdraw方法覆盖了Account类的Withdraw方法。不执行基类的方法中的任何代码。现在您将修改代码，这样当执行CheckingAccount类的代码时，它也会执行基类的Withdraw方法。遵循这些步骤:

1. 找到Account类的Withdraw方法。

2. Change the implementation code so that it decrements the balance by the amount passed to it.

   public virtual double Withdraw(double amount)

   {

   _balance - = amount;

   return Balance;

   }

3. Change the Withdraw method of the CheckingAccount class so that after it checks for sufficient funds, it calls the Withdraw method of the Account base class.

   public override double Withdraw(double amount)

   {

   if (Balance > = amount + GetMinimumBalance())

   {

   return base.Withdraw(amount);

   }

   else

   {

   return -1; //Not enough funds.

   }

   }

4. Add a Withdraw method to the SavingsAccount class that is similar to the Withdraw method of the CheckingAccount class, but does not check for a minimum balance.

   public override double Withdraw(double amount)

   {

   if (Balance > = amount)

   {

   return base.Withdraw(amount);

   }

   else

   {

   return -1; //Not enough funds.

   }

   }

5. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

测试基础改性剂的使用

要测试Withdraw方法，请遵循以下步骤:

1. 选择调试开始。
2. 输入帐号 1，选择“检查”选项按钮，然后单击“获取余额”按钮。你应该得到 1000 英镑的余额。
3. 输入取款金额 600，然后点击取款按钮。您应该会得到 400 英镑的余额。
4. 输入取款金额 300，然后单击取款按钮。您应该得到 a -1(资金不足),因为最终余额将小于 200 的最小值。
5. 输入帐号 1，选择“储蓄”选项按钮，然后单击“获取余额”按钮。你应该得到 1000 英镑的余额。
6. 输入取款金额 600，然后点击取款按钮。您应该会得到 400 英镑的余额。
7. 输入取款金额 300，然后单击取款按钮。您应该得到 100 的结果余额，因为使用Account基类的Withdraw方法的储蓄账户没有最小余额。
8. 测试后，关闭窗体，这将停止调试器。

实现接口

如前所述，您可以创建一个抽象基类，它不包含任何实现代码，但定义了从基类继承的任何类必须使用的方法签名。当使用抽象类时，从它派生的类必须实现它的继承方法。您可以使用另一种技术来实现类似的结果。在这种情况下，不是定义一个抽象类，而是定义一个定义方法签名的接口。

实现接口的类被合同要求实现接口签名定义，并且不能改变它。这种技术有助于确保使用这些类的客户端代码知道哪些方法可用、应该如何调用它们以及预期的返回值。下面的代码显示了如何声明接口定义:

public interface IAccount
{
   string GetAccountInfo(int accountNumber);
}

类通过在类名后使用分号后跟接口名来实现接口。当一个类实现一个接口时，它必须为该接口定义的所有方法提供实现代码。下面的代码演示了CheckingAccount如何实现IAccount接口:

public class CheckingAccount : IAccount
{
    public string GetAccountInfo(int accountNumber)
    {
        return "Printing checking account info";
    }
}

因为实现接口和从抽象基类继承是相似的，所以你可能会问为什么要使用接口。使用接口的一个好处是一个类可以实现多个接口。那个 .NET Framework 不支持从多个类继承。作为多重继承的一种变通方法，实现多个接口的能力也包括在内。接口对于跨不同类型的类实施通用功能也很有用。

理解多态

多态是从同一基类继承的派生类以自己独特的方式响应同一方法调用的能力。这简化了客户端代码，因为客户端代码不需要担心它引用的是哪个类类型，只要这些类类型实现相同的方法接口。

例如，假设您希望银行应用中的所有帐户类都包含一个GetAccountInfo方法，该方法具有相同的接口定义，但基于帐户类型有不同的实现。客户端代码可以遍历一组 account-type 类，编译器将在运行时确定需要执行哪个特定的 account-type 实现。如果您后来添加了一个实现了GetAccountInfo方法的新帐户类型，那么您不需要修改现有的客户端代码。

您可以通过使用继承或实现接口来实现多态。下面的代码演示了继承的用法。首先，定义基类和派生类。

public abstract class Account
{
   public abstract string GetAccountInfo();
}

public class CheckingAccount : Account
{
   public override string GetAccountInfo()
   {
       return "Printing checking account info";
   }
}
public class SavingsAccount : Account
{
    public override string GetAccountInfo()
    {
        return "Printing savings account info";
    }
}

然后创建一个类型为Account的列表，并添加一个CheckingAccount和一个SavingsAccount。

List <Account> AccountList = new List <Account> ();
CheckingAccount oCheckingAccount = new CheckingAccount();
SavingsAccount oSavingsAccount = new SavingsAccount();
AccountList.Add(oCheckingAccount);
AccountList.Add(oSavingsAccount);

然后循环遍历List并调用每个Account的GetAccountInfo方法。每个Account类型都将实现自己的GetAccountInfo实现。

foreach (Account a in AccountList)
{
    MessageBox.Show(a.GetAccountInfo());
}

您也可以通过使用接口获得类似的结果。不是从基类Account继承，而是定义并实现一个IAccount接口。

public interface IAccount
 {
    string GetAccountInfo();
 }

public class CheckingAccount : IAccount
{
    public string GetAccountInfo()
    {
        return "Printing checking account info";
    }
}
public class SavingsAccount : IAccount
{
    public string GetAccountInfo()
    {
        return "Printing savings account info";
    }
}

然后创建一个类型为IAccount的列表，并添加一个CheckingAccount和一个SavingsAccount。

List<IAccount>AccountList = new List<IAccount>();
CheckingAccount oCheckingAccount = new CheckingAccount();
SavingsAccount oSavingsAccount = new SavingsAccount();
AccountList.Add(oCheckingAccount);
AccountList.Add(oSavingsAccount);

然后循环遍历AccountList并调用每个Account的GetAccountInfo方法。每个Account类型都将实现自己的GetAccountInfo实现。

foreach (IAccount a in AccountList)
{
    MessageBox.Show(a.GetAccountInfo());
}

活动 7-3。实现多态

在本活动中，您将熟悉以下内容:

• 通过继承创建多态
• 通过接口创建多态

使用继承实现多态

要使用继承实现多态，请遵循以下步骤:

1. 启动 Visual Studio。选择文件新建项目。

2. 选择 C# 模板下的控制台应用模板。将项目命名为活动 7_3。

3. 该项目包含一个 Program.cs 文件。这个文件包含一个启动 Windows 控制台应用的Main方法。在解决方案资源管理器窗口中右键单击项目节点，并选择 Add class。将文件命名为 Account.cs。

4. In the Account.cs file alter the code to create an abstract base Account class. Include an accountNumber property and an abstract method GetAccountInfo that takes no parameters and returns a string.

   public abstract class Account

   {

   private int _accountNumber;

   public int AccountNumber

   {

   get { return _accountNumber; }

   set { _accountNumber = value; }

   }

   public abstract string GetAccountInfo();

   }

5. Add the following code to create two derived classes: CheckingAccount and SavingsAccount. These classes will override the GetAccountInfo method of the base class.

   public class CheckingAccount : Account

   {

   public override string GetAccountInfo()

   {

   return "Printing checking account info for account number "

   + AccountNumber.ToString();

   }

   }

   public class SavingsAccount : Account

   {

   public override string GetAccountInfo()

   {

   return "Printing savings account info for account number "

   + AccountNumber.ToString();

   }

   }

6. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

测试多态继承方法

要测试多态方法，请遵循以下步骤:

1. 在代码编辑器中打开 Program.cs 文件，找到Main方法。

2. Create an instance of a list of account types.

   List <Account > AccountList = new List <Account> ();

3. Create instances of CheckingAccount and SavingsAccount.

   CheckingAccount oCheckingAccount = new CheckingAccount();

   oCheckingAccount.AccountNumber = 100;

   SavingsAccount oSavingsAccount = new SavingsAccount();

   oSavingsAccount.AccountNumber = 200;

4. Add the oCheckingAccount and oSavingsAccount to the list using the Add method of the list.

   AccountList.Add(oCheckingAccount);

   AccountList.Add(oSavingsAccount);

5. Loop through the list and call the GetAccountInfo method of each account type in the list and show the results in a console window.

   foreach (Account a in AccountList)

   {

   Console.WriteLine(a.GetAccountInfo());

   }

   Console.ReadLine();

6. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

7. 选择调试开始运行项目。您应该看到一个控制台窗口，显示列表中每个对象的GetAccountInfo方法的返回字符串。

8. 测试完多态后，按 enter 键关闭控制台窗口，这将停止调试器。

使用接口实现多态

要使用接口实现多态，请遵循以下步骤:

1. 在代码编辑器中查看 Account.cs 文件的代码。

2. 注释掉Account、CheckingAccount和SavingsAccount类的代码。

3. Define an interface IAccount that contains the GetAccountInfo method.

   public interface IAccount

   {

   string GetAccountInfo();

   }

4. Add the following code to create two classes: CheckingAccount and SavingsAccount. These classes will implement the IAccount interface.

   public class CheckingAccount : IAccount

   {

   private int _accountNumber;

   public int AccountNumber

   {

   get { return _accountNumber; }

   set { _accountNumber = value; }

   }

   public string GetAccountInfo()

   {

   return "Printing checking account info for account number "

   + AccountNumber.ToString();

   }

   }

   public class SavingsAccount : IAccount

   {

   private int _accountNumber;

   public int AccountNumber

   {

   get { return _accountNumber; }

   set { _accountNumber = value; }

   }

   public string GetAccountInfo()

   {

   return "Printing savings account info for account number "

   + AccountNumber.ToString();

   }

   }

5. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

测试多态接口方法

要测试多态方法，请遵循以下步骤:

1. 在代码编辑器中打开 Program.cs 文件，找到Main方法。

2. Change the code to create an instance of a list of IAccount types.

   List <IAccount > AccountList = new List <IAccount> ();

3. Change the code for each loop to loop through the list and call the GetAccountInfo method of each IAccount type in the list.

   foreach (IAccount a in AccountList)

   {

   Console.WriteLine(a.GetAccountInfo());

   }

   Console.ReadLine();

4. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

5. 选择调试开始运行项目。您应该看到一个控制台窗口，显示列表中每个对象的GetAccountInfo方法的返回字符串。

6. 测试完多态后，按 enter 键关闭控制台窗口，这将停止调试器。

摘要

本章向您介绍了 OOP 的两个最强大的特性:继承和多态。不管使用什么语言，知道如何实现这些特性是成为一名成功的面向对象程序员的基础。

在第八章中，你将仔细观察应用中的对象是如何协作的。涵盖的主题包括对象如何相互传递消息，事件如何驱动程序，数据如何在类的实例之间共享，以及如何处理异常。

八、实现对象协作

在第七章中，你学习了如何在 C# 中创建和使用类层次结构。那一章还介绍了继承、多态和接口的概念。在这一章中，你将学习如何让应用的对象一起工作来执行任务。您将看到对象如何通过消息传递进行通信，以及事件如何启动应用处理。您还将了解对象如何响应和交流在执行分配给它们的任务时可能出现的异常。

阅读本章后，您应该熟悉以下内容:

• 通过消息传递进行对象通信的过程
• 可能出现的不同类型的消息传递
• 如何在 C# 应用中使用委托
• 对象如何响应事件并发布自己的事件
• 发布和响应异常的过程
• 如何在同一个类的几个实例之间创建共享数据和过程
• 如何异步发出消息调用

通过消息传递进行交流

OOP 的优势之一是它的许多方面都模仿了现实世界。之前，您看到了如何使用公司中的雇员来表示一个Employee类的实例。我们可以将这种类比扩展到类(对象)的实例在应用中如何交互。例如，在大公司中，员工执行专门的功能。一个人负责应付账款的处理，另一个人负责应收账款的操作。当一名员工需要请求服务时——例如带薪休假(PTO)——该员工向她的经理发送一条消息。我们可以将这种交互视为请求者(员工)和服务提供者(经理)之间的服务请求。这个请求可以只涉及一个对象(自助请求)，两个对象，或者它可以是一个复杂的请求者/服务提供者请求链。例如，员工向她的经理申请 PTO，经理反过来与人力资源(HR)部门核实该员工是否有足够的累积时间。在这种情况下，经理既是员工的服务提供者，也是人力资源部门的服务请求者。

定义方法签名

当消息在请求者和服务提供者之间传递时，请求者可能会也可能不会期待响应。例如，当一个员工请求 PTO 时，她希望得到一个表示批准或拒绝的响应。然而，当会计部门发放工资时，员工们并不期望公司里的每个人都会发一封回复邮件来感谢他们！

发布消息时的一个常见要求是包含执行请求所必需的信息。当员工请求 PTO 时，她的经理希望她向他提供她请求的休假日期。在 OOP 术语中，您将方法的名称(请求的服务)和输入参数(请求者提供的信息)称为方法签名。

下面的代码演示了如何在 C# 中定义方法。访问修饰符后面首先是返回类型(如果没有返回值，则使用void),然后是方法名。参数类型和名称列在括号中，用逗号分隔。方法的主体包含在左花括号和右花括号中。

public int AddEmployee(string firstName,string lastName)
{
    //Code to save data to database
}
public void LogMessage(string message)
{
    //Code to write to log file.
}

传递参数

当在类中定义方法时，还必须指示参数是如何传递的。参数可以通过值或引用传递。

如果选择按值传递参数，参数数据的副本将从调用例程传递给请求的方法。被请求的方法使用副本，如果对数据进行了更改，被请求的方法必须将副本传递回调用例程，以便调用者可以选择放弃更改或复制它们。回到公司的类比，想想更新你的员工档案的过程。人力资源部门不会让你直接接触文件；相反，它会向您发送文件中值的副本。您对副本进行更改，然后将其发送回人力资源部门。然后，人力资源部门决定是否将这些更改复制到实际的员工档案中。在 C# 中，默认情况下通过值传递参数，因此不使用关键字。在下面的方法中，参数通过值传递:

public int AddEmployee(string firstName)
{
    //Code to save data to database
}

传递参数的另一种方式是通过引用。在这种情况下，请求代码不会传入数据的副本，而是传递数据所在位置的引用。以前面的例子为例，当您想要进行更新时，人力资源部门不会向您发送员工文件中数据的副本，而是通知您文件的位置，并告诉您去该部门进行更改。在这种情况下，显然，通过引用传递参数会更好。在 C# 代码中，当通过引用传递参数时，使用了ref关键字。下面的代码演示如何定义通过引用传递值的方法:

public int AddEmployee(ref string firstName)
{
    //Code to save data to database
}

当应用被设计为跨处理边界通信的组件时，甚至在不同的计算机上托管时，通过值而不是通过引用传递参数是有利的。通过引用传递参数会导致开销增加，因为当服务提供对象必须使用参数信息时，它需要跨处理边界和网络进行调用。单个处理请求可能会导致请求者和服务器提供者之间的多次来回调用。在维护数据完整性时，通过引用传递值也会导致问题。请求者在服务器不知情或无法控制的情况下，为要操作的数据打开了通道。

另一方面，当调用代码和被请求的方法在同一个处理空间中(可以说，它们占用同一个“隔间”)并且具有明确建立的信任关系时，通过引用传递值可能是更好的选择。在这种情况下，允许直接访问内存存储位置并通过引用传递参数可以提供优于通过值传递参数的性能优势。

通过引用传递参数可能有好处的另一种情况是，如果对象是复杂数据类型，例如另一个对象。在这种情况下，复制数据结构并跨进程和网络边界传递它的开销超过了跨网络重复调用的开销。

注这个 .NET Framework 通过在 XML 结构中序列化和反序列化复杂数据类型，允许您有效地复制和传递这些类型，从而解决了复杂数据类型的问题。

理解事件驱动编程

到目前为止，您已经看到了对象之间的消息传递，其中直接请求启动了消息交互。如果你想一想你在现实生活中是如何与物体互动的，你会经常收到信息来回应已经发生的事件。以办公室为例，当卖三明治的小贩走进大楼时，对讲机会发出信息通知员工午餐车已经到了。这种类型的消息传递被称为广播消息传递。发出一条消息，接收者决定是忽略还是响应这条消息。

发布此事件消息的另一种方式是，接待员向一组员工发送一封电子邮件，这些员工有兴趣知道三明治供应商何时出现。在这种情况下，感兴趣的员工将向接待员订阅以接收事件消息。这种类型的消息传递通常被称为基于订阅的消息传递。

用 .NET 框架是面向对象的、事件驱动的程序。如果您跟踪应用中出现的请求/服务提供者处理链，您就可以确定启动处理的事件。在 Windows 应用的情况下，与 GUI 交互的用户通常会启动事件。例如，用户可以通过单击按钮启动将数据保存到数据库的过程。应用中的类也可以启动事件。当检测到无效登录时，安全类可以广播事件消息。您还可以订阅外部事件。您可以创建一个 Web 服务，当您在股市中跟踪的股票发生变化时，该服务将发出事件通知。您可以编写一个订阅服务并响应事件通知的应用。

理解委托

为了在 C# 中实现基于事件的编程，您必须首先了解委托。委托是指通过调用服务提供者的方法来请求服务。然后，服务提供者将这个服务请求重新路由到另一个服务该请求的方法。委托类可以检查服务请求，并在运行时动态确定将请求路由到哪里。回到公司的类比，当一个经理收到一个服务请求时，她经常将它委托给她部门的一个成员。(事实上，许多人会认为，成功经理的一个共同特点是知道何时以及如何授权。)

创建委托方法时，首先定义委托方法的签名。因为委托方法实际上并不服务于请求，所以它不包含任何实现代码。下面的代码显示了一个用于比较整数值的委托方法:

public delegate Boolean CompareInt(int I1, int I2);

一旦定义了委托方法的签名，就可以创建要委托的方法。这些方法必须与委托方法具有相同的参数和返回类型。下面的代码显示了委托方法将委托给的两个方法:

private Boolean AscendOrder(int I1, int I2)
{
    if (I1 < I2)
        { return true;}
    else
        { return false; }
}
private Boolean DescendOrder(int I1, int I2)
{
    if (I1 > I2)
        { return true; }
    else
        { return false; }
}

一旦定义了委托及其委托方法，就可以使用委托了。下面的代码显示了排序例程的一部分，它根据作为参数传入的SortType来确定调用哪个委托方法:

public void SortIntegers(SortType sortDirection, int[] intArray)
{
    CompareInt CheckOrder;
    if (sortDirection == SortType.Ascending)
        { CheckOrder = new CompareInt(AscendOrder); }
    else
        { CheckOrder = new CompareInt(DescendOrder); }
    // Code continues ...
}

实施事件

在 C# 中，当你想发布事件消息时，首先你要为事件声明一个委托类型。委托类型定义将传递给处理事件的方法的一组参数。

public delegate void DataUpdateEventHandler(string msg);

一旦声明了委托，就声明了委托类型的事件。

public event DataUpdateEventHandler DataUpdate;

当您想要引发事件时，可以通过传入适当的参数来调用事件。

public void SaveInfo()
{
    try
    {
        DataUpdate("Data has been updated");
    }
    catch
    {
        DataUpdate("Data could not be updated");
    }
}

响应事件

为了在客户端代码中使用事件，声明了一个事件处理方法，该方法执行程序逻辑以响应事件。此事件处理程序必须与发出事件的类中声明的事件委托具有相同的方法签名。

void odata_DataUpdate(string msg)
{
    MessageBox.Show(msg);
}

此事件处理程序使用+=运算符向事件源注册。这个过程被称为事件连接。以下代码连接了先前声明的DataUpdate事件的事件处理程序:

Data odata = new Data();
odata.DataUpdate += new DataUpdateEventHandler(odata_DataUpdate);
odata.SaveInfo();

Windows 控件事件处理

Windows 窗体还通过使用+=运算符将事件处理程序绑定到事件来实现事件处理程序。下面的代码将一个按钮绑定到一个点击事件，将一个文本框绑定到一个鼠标按下事件:

this.button1.Click += new System.EventHandler(this.button1_Click);
this.textBox1.MouseDown += new System.Windows.Forms.MouseEventHandler(this.textBox1_MouseDown);

控件事件的事件处理程序方法有两个参数:第一个参数sender，提供对引发事件的对象的引用。第二个参数传递包含特定于正在处理的事件的信息的对象。下面的代码显示了按钮单击事件的事件处理程序方法和文本框鼠标按下事件的事件处理程序。注意如何使用e来确定左键是否被点击。

private void button1_Click(object sender, EventArgs e)
{

}
private void textBox1_MouseDown(object sender, MouseEventArgs e)
{
    if (e.Button == System.Windows.Forms.MouseButtons.Left)
    {
        //code goes here.
    }
}

活动 8-1。发布和响应事件消息

在本活动中，您将学习做以下事情:

• 从服务器类创建和引发事件
• 处理来自客户端类的事件
• 处理 GUI 事件

在类定义中添加和引发事件消息

要在类定义文件中添加和引发事件消息，请遵循以下步骤:

1. 启动 Visual Studio。选择文件新建项目。

2. 选择一个 Windows 窗体应用项目。将项目命名为Activity8_1。

3. A default form is included in the project. Add controls to the form and change the property values, as listed in Table 8-1. Your completed form should look similar to Figure 8-1.

   表 8-1。登录表单和控件属性

   物体	属性	值
   Form1	Name	frmLogin
   	Text	Login
   Label1	Name	lblName
   	Text	Name:
   Label2	Name	lblPassword
   	Text	Password:
   Textbox1	Name	txtName
   	Text	(empty)
   Textbox2	Name	txtPassword
   	Text	(empty)
   	PasswordChar	*
   Button1	Name	btnLogin
   	Text	Login
   Button2	Name	btnClose
   	Text	Close

   

   图 8-1 。完整的登录表单

4. 选择项目添加类别。给类命名Employee。在代码编辑器中打开Employee类代码。

5. Above the class declaration, add the following line of code to define the login event handler delegate. You will use this event to track employee logins to your application.

   public delegate void LoginEventHandler(string loginName, Boolean status);

6. Inside the class declaration, add the following line of code to define the LoginEvent as the delegate type:

   public event LoginEventHandler LoginEvent;

7. Add the following Login method to the class, which will raise the LoginEvent:

   public void Login(string loginName, string password)

   {

   //Data normally retrieved from database.

   if (loginName == "Smith" && password == "js")

   {

   LoginEvent(loginName, true);

   }

   else

   {

   LoginEvent(loginName, false);

   }

   }

8. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

接收客户端类中的事件

要在客户端类中接收事件，请遵循以下步骤:

1. 在设计窗口中打开 frmLogin。

2. 双击登录按钮以查看登录按钮 click 事件处理程序。

3. Add the following code to wire up the Employee class’s LoginEvent with an event handler in the form class:

   private void btnLogin_Click(object sender, EventArgs e)

   {

   Employee oEmployee = new Employee();

   oEmployee.LoginEvent += new LoginEventHandler(oEmployee_LoginEvent);

   oEmployee.Login(txtName.Text, txtPassword.Text);

   }

4. Add the following event handler method to the form that gets called when the Employee class issues a LoginEvent:

   void oEmployee_LoginEvent(string loginName, bool status)

   {

   MessageBox.Show("Login status :" + status);

   }

5. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

6. 选择调试开始运行项目。

7. 要测试以确保引发了Login事件，请输入登录名 Smith 和密码 js。这应该会触发 true 登录状态。

8. 测试登录事件后，关闭窗体，这将停止调试器。

用一种方法处理多个事件

要用一种方法处理多个事件，请遵循以下步骤:

1. 通过在解决方案资源管理器中右键单击 frmLogin 节点并选择“视图设计器”,在窗体设计器中打开 frmLogin。

2. From the Toolbox, add a MenuStrip control to the form. Click where it says “Type Here” and enter File for the top-level menu and Exit for its submenu, as shown in Figure 8-2.

   

   图 8-2 。添加 MenuStrip 控件

3. Add the following method to handle the click event of the menu and the Close button:

   private void FormClose(object sender, EventArgs e)

   {

   this.Close();

   }

4. Open frmLogin in the designer window. In the properties window, select the exitToolStripMenuItem. Select the event button (lightning bolt) at the top of the properties window to show the events of the control. In the click event drop-down, select the FormClose method (see Figure 8-3).

   

   图 8-3 。连接事件处理程序

5. 重复步骤 4 将btnClose按钮点击事件绑定到FormClose方法。

6. 在解决方案窗口中展开 Form1.cs 节点。右键单击表格 1。Designer.cs 节点并选择“查看代码”。

7. In the code editor, expand the Windows Form Designer generated code region. Search for the code listed below. This code was generated by the form designer to wire up the events to the FormClose method.

   this.btnClose.Click += new System.EventHandler(this.FormClose);

   this.exitToolStripMenuItem.Click += new System.EventHandler(this.FormClose);

8. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

9. 选择调试开始运行项目。测试退出菜单和关闭按钮。

10. 测试后，保存项目，然后退出 Visual Studio。

中处理异常 .NET 框架

当对象协作时，事情可能会出错。异常是在正常处理过程中不希望发生的事情。例如，当连接失败时，您可能试图通过网络将数据保存到数据库中，或者您可能试图将数据保存到驱动器中没有磁盘的驱动器中。您的应用应该能够优雅地处理应用处理过程中发生的任何异常。

的 .NET 框架使用结构化的异常处理机制。以下是这种结构化异常处理的一些优势:

• 所有人的共同支持和结构 .NET 语言
• 支持创建受保护的代码块
• 过滤异常以创建高效可靠的错误处理的能力
• 支持终止处理程序，以保证完成清理任务，而不管可能遇到的任何异常

的 .NET Framework 还提供了大量的异常类，用于处理可能发生的常见异常。例如，FileNotFoundException类封装了诸如文件名、错误消息以及当试图访问一个不存在的文件时抛出的异常的来源等信息。此外 .NET Framework 允许创建应用特定的异常类，您可以编写这些异常类来处理应用特有的常见异常。

使用 Try-Catch 块

当创建可能导致异常的代码时，您应该将它放在try块中。放置在try块中的代码被认为是受保护的。如果在受保护代码执行过程中出现异常，代码处理将被转移到catch块，在那里进行处理。下面的代码演示了一个类的方法，该方法尝试从不存在的文件中读取数据。当抛出异常时，它被捕获在catch块中。

public string ReadText(string filePath)
{
    StreamReader sr;
    try
    {
        sr = File.OpenText(filePath);
        string fileText = sr.ReadToEnd();
        sr.Close();
        return fileText;
    }
    catch(Exception ex)
    {
        return ex.Message;
    }
}

所有的try块都需要至少一个嵌套的catch块。您可以使用catch块来捕获try块中可能出现的所有异常，或者您可以使用它根据异常的类型来过滤异常。这使您能够根据异常类型动态响应不同的异常。下面的代码演示了如何根据从磁盘读取文本文件时可能发生的不同异常来筛选异常:

public string ReadText(string filePath)
{
    StreamReader sr;
    try
    {
        sr = File.OpenText(filePath);
        string fileText = sr.ReadToEnd();
        sr.Close();
        return fileText;
    }
    catch (DirectoryNotFoundException ex)
    {
        return ex.Message;
    }
    catch (FileNotFoundException ex)
    {
        return ex.Message;
    }
    catch(Exception ex)
    {
        return ex.Message;
    }
}

添加 Finally 块

此外，您可以在try块的末尾嵌套一个finally块。与catch块不同，finally块的使用是可选的。finally块用于任何需要发生的清理代码，即使遇到异常。例如，您可能需要关闭数据库连接或释放文件。当try块的代码被执行并且异常发生时，处理将评估每个catch块，直到找到合适的捕捉条件。在catch块执行后，将执行finally块。如果try块执行并且没有遇到异常，那么catch块不会执行，但是finally块仍然会被处理。下面的代码显示了一个用于关闭和释放StreamReader的finally块:

public string ReadText(string filePath)
{
    StreamReader sr = null;
    try
    {
        sr = File.OpenText(filePath);
        string fileText = sr.ReadToEnd();
        return fileText;
    }
    catch (DirectoryNotFoundException ex)
    {
        return ex.Message;
    }
    catch (FileNotFoundException ex)
    {
        return ex.Message;
    }
    catch (Exception ex)
    {
        return ex.Message;
    }
        finally
    {
        if (sr != null)
        {
            sr.Close();
            sr.Dispose();
        }
    }
}

抛出异常

在代码执行期间，当进行不适当的调用时，例如，方法的参数具有无效值或者传递给方法的参数导致异常，您可以抛出异常来通知调用代码违规。在下面的代码中，如果orderDate参数大于当前日期，就会向调用代码抛出一个ArgumentOutOfRangeException,通知它们发生了冲突。

if (orderDate > DateTime.Now)
{
    throw new ArgumentOutOfRangeException ("Order date can not be in the future.");
}
//Processing code...

注意如果在 .NET Framework，您可以创建一个从System.Exception类派生的自定义异常类。

嵌套异常处理

在某些情况下，您可能能够纠正发生的异常，并继续处理try块中剩余的代码。例如，可能会出现被零除的错误，将结果赋值为零并继续处理是可以接受的。在这种情况下，try-catch 块可以嵌套在导致异常的代码行周围。处理完异常后，处理将返回到嵌套的try块之后的外层try-catch块中的代码行。下面的代码演示了如何将一个try块嵌套在另一个块中:

try
{
    try
    {
        Y = X1 / X2;
    }
    catch (DivideByZeroException ex)
    {
        Y = 0;
    }
    //Rest of processing code.
}
catch (Exception ex)
{
    //Outer exception processing
}

注了解更多关于处理异常和 .NET 框架异常类，请参考附录 b。

静态属性和方法

当您声明一个类的对象实例时，该对象实例化它所实现的类的属性和方法的自己的实例。例如，如果你要写一个增加计数器的计数例程，然后实例化该类的两个对象实例，每个对象的计数器将彼此独立；当您增加一个计数器时，另一个不会受到影响。正常情况下，这种对象独立性就是你想要的行为。但是，有时您可能希望一个类的不同对象实例访问相同的共享变量。例如，您可能希望构建一个计数器，记录已经实例化了多少个对象实例。在这种情况下，您将在类定义中创建一个静态属性值。以下代码演示了如何在类定义中创建静态TaxRate属性:

public class AccountingUtilities
{
    private static double _taxRate = 0.06;

    public static double TaxRate
    {
        get { return _taxRate; }
    }
}

要访问静态属性，不需要创建该类的对象实例；相反，您可以直接引用该类。下面的代码显示了一个访问先前定义的静态属性TaxRate的客户端:

public class Purchase
{
    public double CalculateTax(double purchasePrice)
    {
        return purchasePrice * AccountingUtilities.TaxRate;
    }
}

如果您有客户端需要访问的实用函数，但是您不希望通过创建类的对象实例来获得对方法的访问，那么静态方法是非常有用的。请注意，静态方法只能访问静态属性。下面的代码显示了一个静态方法，用于计算当前登录到应用的用户数量:

public class UserLog
{
    private static int _userCount;
    public static void IncrementUserCount()
    {
        _userCount += 1;
    }
    public static void DecrementUserCount()
    {
        _userCount -= 1;
    }
}

当客户端代码访问静态方法时，它通过直接引用该类来实现。下面的代码演示了如何访问前面定义的静态方法:

public class User
{
    //other code ...
    public void Login(string userName, string password)
    {
        //code to check credentials
        //if successful
        UserLog.IncrementUserCount();
    }
}

虽然在应用中创建类时可能不经常使用静态属性和方法，但它们在创建基类库时很有用，并且在整个 .NET Framework 系统类。下面的代码演示了System.String类的Compare方法的使用。这是一个静态方法，按字母顺序比较两个字符串。如果第一个字符串大于，则返回正值；如果第二个字符串大于，则返回负值；如果两个字符串相等，则返回零。

public Boolean CheckStringOrder(string string1, string string2)
{
    if (string.Compare(string1, string2) >= 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

活动 8-2。实现异常处理和静态方法

在本活动中，您将学习如何执行以下操作:

• 创建并调用类的静态方法
• 使用结构化异常处理

创建静态方法

要创建静态方法，遵循以下步骤:

1. 启动 Visual Studio。选择文件新建项目。

2. 选择一个 Windows 应用项目。将项目命名为 Activity8_2。

3. Visual Studio creates a default form for the project which you’ll use to create a login form named Logger. Add controls to the form and change the property values, as listed in Table 8-2. Your completed form should look similar to Figure 8-4.

   

   图 8-4 。已完成的记录器表单

   表 8-2。记录器表单和控件属性

   物体	属性	值
   Form1	Name	frmLogger
   	Text	Logger
   Textbox1	Name	txtLogPath
   	Text	c:\Test\LogTest.txt
   Textbox2	Name	txtLogInfo
   	Text	Test Message
   Button1	Name	btnL ogInfo
   	Text	Log Info

4. 选择项目添加类。给类命名Logger。

5. Because you will be using the System.IO class within the Logger class, add a using statement to the top of the class file:

   using System.IO;

6. Add a static LogWrite method to the class. This method will write information to a log file. To open the file, create a FileStream object. Then create a StreamWriter object to write the information to the file. Notice the use of the using blocks to properly dispose the FileStream and StreamWriter objects and release the resources.

   public static string LogWrite(string logPath, string logInfo)

   {

   using (FileStream oFileStream = new FileStream(logPath, FileMode.Open, FileAccess.Write))

   {

   using (StreamWriter oStreamWriter = new StreamWriter(oFileStream))

   {

   oFileStream.Seek(0, SeekOrigin.End);

   oStreamWriter.WriteLine(DateTime.Now);

   oStreamWriter.WriteLine(logInfo);

   oStreamWriter.WriteLine();

   }

   }

   return "Info Logged";

   }

7. Open frmLogger in the visual design editor. Double click the btnLogInfo button to bring up the btnLogInfo_Click event method in the code editor. Add the following code, which runs the LogWrite method of the Logger class and displays the results in the form’s text property. Note that because you designated the LogWrite method as static (in step 6), the client does not need to create an object instance of the Logger class. Static methods are accessed directly through a class reference.

   private void btnLogInfo_Click(object sender, EventArgs e)

   {

   this.Text = Logger.LogWrite(txtLogPath.Text, txtLogInfo.Text);

   }

8. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

9. 选择调试运行。当表单启动时，单击 Log Info 按钮。您应该得到一个类型为System.IO.DirectoryNotFoundException的未处理异常消息。停止调试器。

创建结构化异常处理程序

要创建结构化异常处理程序，请遵循以下步骤:

1. 在代码编辑器中打开Logger类代码。

2. Locate the LogWrite method and add a try-catch block around the current code. In the catch block, return a string stating the logging failed.

   try

   {

   using (FileStream oFileStream = new FileStream(logPath, FileMode.Open, FileAccess.Write))

   {

   using (StreamWriter oStreamWriter = new StreamWriter(oFileStream))

   {

   oFileStream.Seek(0, SeekOrigin.End);

   oStreamWriter.WriteLine(DateTime.Now);

   oStreamWriter.WriteLine(logInfo);

   oStreamWriter.WriteLine();

   }

   }

   return "Info Logged";}

   catch

   {

   return "Logging Failed";

   }

3. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

4. 选择调试运行。当表单启动时，单击 Log Info 按钮。这一次，您应该不会得到异常消息，因为它是由LogWrite方法处理的。您应该会在表单的标题中看到消息“日志记录失败”。关闭表单。

过滤异常

要过滤例外情况，请遵循以下步骤:

1. Alter the catch block to return different messages, depending on which exception is thrown.

   catch (FileNotFoundException ex)

   {

   return ex.Message;

   }

   catch (IOException ex)

   {

   return ex.Message;

   }

   catch

   {

   return "Logging Failed";

   }

2. 在 Logger 类的LogWrite方法上设置断点。

3. 选择调试开始运行项目。通过单击日志信息按钮测试 catch 块。执行将在断点处停止。单步执行代码，注意它被IOException块捕获。

4. 测试后，关闭表单。

5. 使用记事本，在 c 盘上的测试文件夹中创建 LogTest.txt 文件，并关闭该文件。确保文件和文件夹未被标记为只读。

6. 选择调试开始运行项目。点击日志信息按钮，测试WriteLog方法。这一次，表单的标题应该表明日志写入成功。

7. 停止调试器。

8. 使用记事本打开 LogTest.txt 文件，并验证是否记录了信息。

9. 保存项目，然后退出 Visual Studio。

使用异步消息传递

当对象通过来回传递消息进行交互时，它们可以同步或异步传递消息。

当客户机对象对服务器对象进行同步消息调用时，客户机暂停处理，并在继续之前等待来自服务器的响应。同步消息传递是最容易实现的，也是 .NET 框架。然而，有时这是一种低效的消息传递方式。例如，同步消息传递模型不太适合长时间运行的文件读写、跨慢速网络进行服务调用，或者在客户端断开连接的情况下进行消息排队。为了更有效地处理这些类型的情况 .NET Framework 提供了在对象之间异步传递消息所需的管道。

当客户端对象异步传递消息时，客户端可以继续处理。服务器完成消息请求后，响应信息将被发送回客户端。

如果你想一想，你与现实世界中的对象进行同步和异步的交互。同步消息传递的一个很好的例子是当你在杂货店排队结账时。当店员不能确定其中一个商品的价格时，他会打电话给经理进行价格检查，并暂停结账过程，直到返回结果。异步消息调用的一个例子是当职员注意到他的零钱不够时。他提醒经理，他很快就需要更改，但他可以继续处理客户的商品，直到更改到来。

为了使异步编程更容易实现 .NET Framework 4.5 引入了基于任务的异步模式(TAP) 。当符合 TAP 时，异步方法返回一个任务对象。此任务对象表示正在进行的操作，并允许与调用者进行通信。当调用异步方法时，客户端只需使用 await 修饰符，编译器负责所有必要的管道代码。

在 .NET Framework 中，当您想要创建一个可以异步调用的方法时，您可以使用async修饰符。异步方法提供了一种在不阻塞调用者的情况下执行潜在的长时间运行流程的方法。如果包含用户界面(UI)的主线程需要调用长时间运行的进程，这将非常有用。如果进程被同步调用，那么 UI 将冻结，直到进程完成。

一个异步方法应该包含至少一个await语句。当遇到await语句时，处理被挂起，控制权返回给调用者(本例中是 UI)。因此用户可以继续与 UI 进行交互。一旦异步任务完成，处理返回 await 语句，调用者可以得到处理完成的提示。为了提醒调用者流程已经完成，您创建了一个Task返回类型。如果 async 方法需要将信息传递回调用者，则使用Task<TResult>。下面的代码显示了一个异步读取文本文件的方法。注意用于调用StreamReader类的ReadToEndAsync方法的async修饰符和await关键字。该方法通过一个字符串结果将一个Task对象传递回调用者。

public static async Task<string> LogReadAsync(string filePath)
{
    StreamReader oStreamReader;
    string fileText;
        try
        {
            oStreamReader = File.OpenText(filePath);
            fileText = await oStreamReader.ReadToEndAsync();
            oStreamReader.Close();
            return fileText;
        }
        catch (FileNotFoundException ex)
        {
            return ex.Message;
        }
        catch (IOException ex)
        {
            return ex.Message;
        }
        catch
        {
            return "Logging Failed";
        }
}

活动 8-3。异步调用方法

在本活动中，您将学习如何执行以下操作:

• 同步调用方法
• 异步调用方法

创建一个方法并同步调用它

要创建方法并同步调用它，请遵循以下步骤:

1. 启动 Visual Studio。选择文件打开项目。

2. 打开您在练习 8_2 中完成的解决方案文件。

3. Add the buttons shown in Table 8-3 to the frmLogger form. Figure 8-5 shows the completed form.

   

   图 8-5 。用于同步和异步读取的完整记录器表单

   表 8-3。记录器表单的附加按钮

   物体	属性	值
   Button1	Name	btnSyncRead
   	Text	Sync Read
   Button2	Name	btnAsyncRead
   	Text	Async Read
   Button3	Name	btnMessage
   	Text	Message

4. 在代码编辑器中打开Logger类。

5. Recall that because you are using the System.IO namespace within the Logger class, you added a using statement to the top of the file. You are also going to use System.Threading namespace, so add a using statement to include this namespace.

   using System.Threading;

6. Add a static LogRead function to the class. This function will read information from a log file. To open the file, create a FileStream object. Then create StreamReader object to read the information from the file. You are also using the Thread class to suspend processing for five seconds to simulate a long call across a slow network.

   public static string LogRead(string filePath)

   {

   StreamReader oStreamReader;

   string fileText;

   try

   {

   oStreamReader = File.OpenText(filePath);

   fileText = oStreamReader.ReadToEnd();

   oStreamReader.Close();

   Thread.Sleep(5000);

   return fileText;

   }

   catch (FileNotFoundException ex)

   {

   return ex.Message;

   }

   catch (IOException ex)

   {

   return ex.Message;

   }

   catch

   {

   return "Logging Failed";

   }

   }

7. Open frmLogger in the visual design editor. Double click the btnMessage button to bring up the btnMessage_Click event method in the code editor. Add code to display a message box.

   private void btnMessage_Click(object sender, EventArgs e)

   {

   MessageBox.Show("Hello");

   }

8. Open frmLogger in the visual design editor. Double-click the btnSyncRead button to bring up the btnSyncRead_Click event method in the code editor. Add code that calls the LogRead method of the Logger class and displays the results in a message box.

   private void btnSyncRead_Click(object sender, EventArgs e)

   {

   MessageBox.Show(Logger.LogRead(txtLogPath.Text));

   }

9. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

10. 选择调试运行。当表单启动时，单击同步读取按钮。点按“同步阅读”按钮后，尝试点按“邮件”按钮。当点击消息按钮时，您应该不会得到响应，因为您同步调用了ReadLog方法。ReadLog 方法返回结果后，单击消息按钮将会响应。

11. 完成测试后，关闭表单。

创建和调用异步方法

要创建异步方法，请遵循以下步骤:

1. 在代码编辑器中打开Logger类代码。

2. Check for the following using statement at the top of the file. This namespace exposes the Task class and other types that are used to implement asynchronous programming.

   using System.Threading.Tasks;

3. Create an asynchronous method that reads the text file. The use of the Task’s Delay method is to simulate a long running process.

   public static async Task<string> LogReadAsync(string filePath)

   {

   string fileText;

   try

   {

   using (StreamReader oStreamReader = File.OpenText(filePath))

   {

   fileText = await oStreamReader.ReadToEndAsync();

   }

   await Task.Delay(10000);

   return fileText;

   }

   catch (FileNotFoundException ex)

   {

   return ex.Message;

   }

   catch (IOException ex)

   {

   return ex.Message;

   }

   catch

   {

   return "Logging Failed";

   }

   }

4. Open frmLogger in the visual design editor. Double-click the btnAsyncRead button to bring up the btnAsyncRead_Click event method in the code editor. Alter the method so that it is asynchronous.

   private async void btnAsyncRead_Click(object sender, EventArgs e)

5. Add code to call the LogReadAsync method of the Logger class and display the results in a message box.

   btnAsyncRead.Enabled = false;

   string s = await Logger.LogReadAsync(txtLogPath.Text);

   MessageBox.Show(s);

   btnAsyncRead.Enabled = true;

6. 选择构建构建解决方案。确保"错误列表"窗口中没有生成错误。如果有，修复它们，然后重新构建。

7. 选择调试运行。当表单启动时，单击异步读取按钮。单击异步读取按钮后，单击消息按钮。这一次，您应该得到一个响应，因为您异步调用了ReadLog方法。五秒钟后，您应该会看到一个消息框，其中包含了Logger.LogReadAsync方法的结果。

8. 完成测试后，关闭表单。

9. 保存项目，然后退出 Visual Studio。

摘要

本章描述了应用中的对象如何协作。您看到了对象如何相互传递消息，事件如何驱动程序，类的实例如何共享数据，以及如何处理异常。

在第九章中，我们看集合和数组。集合和数组将相似的对象组织成一个组。使用集合是您需要在应用中应用的最常见的编程结构之一。您将研究. NET Framework 中可用的一些基本集合类型，并学习如何在代码中使用集合。

九、使用集合

在前一章中，你已经看到了在面向对象的程序中对象是如何协作和通信的。那一章介绍了消息传递、事件、委托、异常处理和异步编程的概念。在这一章中，你将会看到对象集合是如何被组织和处理的。那个 .NET Framework 包含一组用于创建和管理对象集合的广泛的类和接口。您将看到各种类型的集合结构 .NET 提供并了解它们的设计目的以及何时使用它们。您还将看到如何使用泛型来创建高度可重用、高效的集合。

在本章中，您将学习以下内容:

• 公开的各种类型的集合 .NET 框架
• 如何使用数组和数组列表
• 如何创建通用集合
• 如何实现队列和堆栈

介绍 .NET Framework 集合类型

程序员经常需要处理类型的集合。例如，如果你在一个工资系统中处理雇员时间记录，你需要按雇员对记录进行分组，循环遍历记录，并把每个记录的时间加起来。

所有的集合都需要一组基本的函数，比如添加对象、移除对象和遍历它们的对象。除了基本集合之外，一些集合还需要额外的专门功能。例如，在向帮助台电子邮件请求集合中添加和删除项目时，该集合可能需要实现先进先出功能。另一方面，如果请求按严重性划分优先级，那么集合需要能够按优先级对其项目进行排序。

那个 .NET Framework 提供了各种基本的和专门的集合类供您使用。System.Collections名称空间包含定义各种类型集合的接口和类，例如列表、队列、哈希表和字典。表 9-1 列出并描述了一些常用的收集类。如果没有找到具有所需功能的集合类，可以扩展. NET Framework 类来创建自己的集合类。

表 9-1。常用集合类

类	描述
Array	为支持强类型数组的语言实现提供基类。
ArrayList	使用大小根据需要动态增加的数组表示弱类型对象列表。
SortedList	表示按键排序并可按键和索引访问的键/值对的集合。
Queue	表示对象的先进先出(FIFO)集合。
Stack	表示简单的后进先出(LIFO)的非泛型对象集合。
Hashtable	表示基于键的哈希代码组织的键/值对的集合。
CollectionBase	为强类型集合提供抽象基类。
DictionaryBase	为键/值对的强类型集合提供抽象基类。

表 9-2 描述了这些集合类实现的一些接口。

表 9-2 。集合类接口

界面	描述
ICollection	为所有非泛型集合定义大小、枚举数和同步方法。
IComparer	公开比较两个对象的方法。
IDictionary	表示键/值对的非泛型集合。
IDictionaryEnumerator	枚举非泛型字典的元素。
IEnumerable	公开枚举数，该枚举数支持对非泛型集合的简单迭代。
IEnumerator	支持对非泛型集合的简单迭代。
IList	表示可以通过索引单独访问的对象的非一般集合。

在本章中，您将使用一些常用的集合类，从Array和ArrayList类开始。

使用数组和数组列表

数组是计算机编程中最常见的数据结构之一。数组保存相同数据类型的数据元素。例如，你可以创建一个整数、字符串或日期的数组。数组通常用于将值作为参数传递给方法。例如，当您使用控制台应用时，通常会提供命令行开关。下面的 DOS 命令用来在你的电脑上复制一个文件:

copy win.ini c:\windows /y

源文件、目标路径和覆盖指示符作为字符串数组传递到复制程序中。

通过数组的索引来访问数组的元素。索引是一个整数，表示元素在数组中的位置。例如，表示一周中各天的字符串数组具有以下索引值:

| 索引 | 值 |
| Zero | 在星期日 |
| one | 星期一 |
| Two | 星期二 |
| three | 星期三 |
| four | 星期四 |
| five | 星期五 |
| six | 星期六 |

这个星期几的例子是一个一维数组，这意味着索引由单个整数表示。数组也可以是多维的。多维数组元素的索引是一组等于维数的整数。图 9-1 显示了一个座位表，表示一个二维数组，其中一个学生的名字(值)被一对有序的行号、座位号(索引)引用。

图 9-1 。二维数组

当您声明数组的类型时，就实现了数组功能。作为数组实现的常见类型是数字类型，如整数或双精度类型，以及字符和字符串类型。将类型声明为数组时，在类型后使用方括号([])，后跟数组的名称。数组的元素由一个用花括号({})括起来的逗号分隔的列表指定。例如，下面的代码声明了一个类型为int的数组，并用五个值填充它:

int[] intArray = { 1, 2, 3, 4, 5 };

一旦一个类型被声明为数组，就暴露了Array类的属性和方法。一些功能包括查询数组的上限和下限、更新数组的元素以及复制数组的元素。Array类包含许多用于处理数组的静态方法，比如清除、反转和排序数组元素的方法。

下面的代码演示如何声明和使用整数数组。它还使用了几个由Array类公开的静态方法。注意用于列出数组值的foreach循环。foreach循环提供了一种遍历数组元素的方法。

int[] intArray = { 1, 2, 3, 4, 5 };
Console.WriteLine("Upper Bound");
Console.WriteLine(intArray.GetUpperBound(0));
Console.WriteLine("Array elements");
foreach (int item in intArray)
{
Console.WriteLine(item);
}
Array.Reverse(intArray);
Console.WriteLine("Array reversed");
foreach (int item in intArray)
{
    Console.WriteLine(item);
}
Array.Clear(intArray, 2, 2);
Console.WriteLine("Elements 2 and 3 cleared");
foreach (int item in intArray)
{
    Console.WriteLine(item);
}
intArray[4] = 9;
Console.WriteLine("Element 4 reset");
foreach (int item in intArray)
{
    Console.WriteLine(item);
}
Console.ReadLine();

图 9-2 显示了控制台窗口中这段代码的输出。

图 9-2 。一维数组输出

虽然一维数组是您将遇到的最常见的类型，但是您应该理解如何处理偶尔出现的多维数组。二维数组用于存储(在活动内存中)和处理适合表的行和列的数据。例如，您可能需要处理几天内每小时进行的一系列测量(温度或辐射水平)。要创建多维数组，可以在方括号内放置一个或多个逗号来表示维数。一个逗号表示两个维度；两个逗号表示三维，依此类推。填充多维数组时，花括号中的花括号定义了元素。下面的代码声明并填充一个二维数组:

int[,] twoDArray = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
//Print the index and value of the elements
for (int i = 0; i <= twoDArray.GetUpperBound(0); i++)
{
     for (int x = 0; x <= twoDArray.GetUpperBound(1); x++)
     {
          Console.WriteLine("Index = [{0},{1}]  Value = {2}", i, x, twoDArray[i, x]);
     }
}

图 9-3 显示了控制台窗口中该代码的输出。

图 9-3 。二维数组输出

当您使用集合时，通常直到运行时才知道它们需要包含的项数。这就是ArrayList类适合的地方。数组列表的容量会根据需要自动扩展，内存重新分配和元素复制会自动执行。ArrayList类还提供了Array类没有提供的处理数组元素的方法和属性。下面的代码演示了其中的一些属性和方法。请注意，随着更多姓名的添加，列表的容量会动态扩展。

ArrayList nameList = new ArrayList();
nameList.Add("Bob");
nameList.Add("Dan");
nameList.Add("Wendy");
Console.WriteLine("Original Capacity");
Console.WriteLine(nameList.Capacity);
Console.WriteLine("Original Values");
foreach (object name in nameList)
{
    Console.WriteLine(name);
}

nameList.Insert(nameList.IndexOf("Dan"), "Cindy");
nameList.Insert(nameList.IndexOf("Wendy"), "Jim");
Console.WriteLine("New Capacity");
Console.WriteLine(nameList.Capacity);
Console.WriteLine("New Values");
foreach (object name in nameList)
{
    Console.WriteLine(name);
}

图 9-4 显示了控制台窗口中的输出。

图 9-4 。数组列表输出

虽然使用数组列表通常比使用数组更容易，但是数组列表只能有一维。此外，特定类型的数组比数组列表提供更好的性能，因为ArrayList的元素属于类型Object。当类型被添加到数组列表中时，它们被转换为通用的Object类型。当从列表中检索项目时，必须再次将它们转换为特定类型。

活动 9-1。使用数组和数组列表

在本活动中，您将熟悉以下内容:

• 创建和使用数组
• 使用多维数组
• 使用数组列表

创建和使用数组

要创建并填充一个数组，遵循以下步骤:

1. 启动 Visual Studio。选择文件新建项目。

2. 选择控制台应用项目。将项目命名为 Activity9_1。控制台应用包含一个名为 Program 的类，它有一个 Main 方法。Main 方法是应用启动时访问的第一个方法。

3. Notice that the Main method accepts an input parameter of a string array called args. The args array contains any command line arguments passed in when the console application is launched. The members of the args array are separated by a space when passed in.

   static void Main(string[] args)

   {

   }

4. Add the following code to the Main method to display the command line arguments passed in:

   Console.WriteLine("parameter count = {0}", args.Length);

   for (int i = 0; i < args.Length; i++)

   {

   Console.WriteLine("Arg[{0}] = [{1}]", i, args[i]);

   }

   Console.ReadLine();

5. In Solution Explorer, right-click the project node and choose Properties. In the project properties window, select the Debug tab. In the command line arguments field, enter “C# coding is fun” (see Figure 9-5).

   

   图 9-5 。添加命令行参数

6. Select Debug Start to run the project. The console window should launch with the output shown in Figure 9-6. After viewing the output, stop the debugger.

   

   图 9-6 。控制台输出为阵列

7. Add the following code before the Console.ReadLine method in the Main method. This code clears the value of the array at index 1 and sets the value at index 3 to “great”.

   Array.Clear(args, 1, 1);

   args[3] = "great";

   for (int i = 0; i < args.Length; i++)

   {

   Console.WriteLine("Arg[{0}] = [{1}]", i, args[i]);

   }

8. Select Debug Start to run the project. The console window should launch with the additional output shown in Figure 9-7. After viewing the output, stop the debugger.

   

   图 9-7 。更新阵列的控制台输出

使用多维数组

要创建和填充多维数组，请遵循以下步骤:

1. 注释掉Main方法中的代码。

2. Add the following code to the Main method to create and populate a two-dimensional array:

   string[,] seatingChart = new string[2,2];

   seatingChart[0, 0] = "Mary";

   seatingChart[0, 1] = "Jim";

   seatingChart[1, 0] = "Bob";

   seatingChart[1, 1] = "Jane";

3. Add the following code to loop through the array and print the names to the console window:

   for (int row = 0; row < 2; row++)

   {

   for (int seat = 0; seat < 2; seat++)

   {

   Console.WriteLine("Row: {0} Seat: {1} Student: {2}",

   (row + 1),(seat + 1),seatingChart[row, seat]);

   }

   }

   Console.ReadLine();

4. Select Debug Start to run the project. The console window should launch with the output that shows the seating chart of the students (see Figure 9-8).

   

   图 9-8 。二维数组的控制台输出

5. 查看输出后，停止调试器。

使用数组列表

虽然您刚刚创建的二维数组可以工作，但是将每个学生的座位分配信息存储在座位分配类中，然后将这些对象组织到一个数组列表结构中可能更直观。要创建和填充座位分配的数组列表，请按照下列步骤操作:

1. 向名为 SeatingAssignment.cs 的项目添加一个类文件。

2. Add the following code to create the SeatingAssignment class. This class contains a Row, Seat, and Student property. It also contains an overloaded constructor to set these properties.

   public class SeatingAssignment

   {

   int _row;

   int _seat;

   string _student;

   public int Row

   {

   get { return _row; }

   set { _row = value; }

   }

   public int Seat

   {

   get { return _seat; }

   set { _seat = value; }

   }

   public string Student

   {

   get { return _student; }

   set { _student = value; }

   }

   public SeatingAssignment(int row, int seat, string student)

   {

   this.Row = row;

   this.Seat = seat;

   this.Student = student;

   }

   }

3. In the Main method of the Program class, comment out the previous code and add the following using statement to the top of the file:

   using System.Collections;

4. Add the following code to create an ArrayList of seating assignments:

   ArrayList seatingChart = new ArrayList();

   seatingChart.Add(new SeatingAssignment(0, 0, "Mary"));

   seatingChart.Add(new SeatingAssignment(0, 1, "Jim"));

   seatingChart.Add(new SeatingAssignment(1, 0, "Bob"));

   seatingChart.Add(new SeatingAssignment(1, 1, "Jane"));

5. After the ArrayList is populated, add the following code to write the SeatingAssignment information to the console window.

   foreach (SeatingAssignment sa in seatingChart)

   {

   Console.WriteLine("Row: {0} Seat: {1} Student: {2}",

   (sa.Row + 1), (sa.Seat + 1), sa.Student);

   }

   Console.ReadLine();

6. 选择调试开始运行项目。控制台窗口应启动，输出与图 9-8 (学生座位表)所示的相同。

7. One of the advantages of the ArrayList class is the ability to add and remove items dynamically. Add the following code after the code in step 4 to add two more students to the seating chart:

   seatingChart.Add(new SeatingAssignment(2, 0, "Bill"));

   seatingChart.Add(new SeatingAssignment(2, 1, "Judy"));

8. 选择调试开始运行项目。控制台窗口应该启动，输出显示新学生。

9. 完成后，停止调试器，并关闭 Visual Studio。

使用泛型集合

使用集合是应用编程的常见要求。我们处理的大多数数据都需要组织成一个集合。例如，您可能需要从数据库中检索客户，并将他们加载到 UI(用户界面)的下拉列表中。客户信息由一个客户类表示，客户被组织到一个客户集合中。然后可以对集合进行排序、过滤和循环处理。

除了少数强类型的用于保存字符串的专用集合之外，由 .NET 框架是弱类型的。集合持有的项目属于类型Object，因此它们可以是任何类型，因为所有类型都是从类型Object派生的。

弱类型集合会导致应用的性能和维护问题。一个问题是没有内在的安全措施来限制存储在集合中的对象类型。同一个集合可以包含任何类型的项，包括日期、整数或自定义类型，如 employee 对象。如果您构建并公开了一个整数集合，而该集合无意中被传递了一个日期，那么代码很可能会在某个时候失败。

幸运的是，C# 支持泛型 .NET Framework 在System.Collections.Generic命名空间中提供了基于泛型的集合。泛型允许您定义一个类，而无需指定它的类型。类型是在类被实例化时指定的。使用泛型集合提供了类型安全的优势和强类型集合的性能，同时还提供了与弱类型集合相关联的代码重用。

下面的代码展示了如何使用Generic.List类创建客户的强类型集合。列表类型(在本例中为Customer)放在尖括号(<>)之间。Customer 对象被添加到集合中，然后检索集合中的客户，并将客户信息写出到控制台。(你会在第十一章看到将集合绑定到 UI 控件。)

List<Customer> customerList = new List<Customer>();
customerList.Add(new Customer
    ("WHITC", "White Clover Markets", "Karl Jablonski"));
customerList.Add(new Customer("RANCH", "Rancho grande", "Sergio Gutiérrez"));
customerList.Add(new Customer("ALFKI","Alfreds Futterkiste","Maria Anders"));
customerList.Add
    (new Customer("FRANR", "France restauration", "Carine Schmitt"));
foreach (Customer c in customerList)
{
    Console.WriteLine("Id: {0} Company: {1} Contact: {2}",
                    c.CompanyId, c.CompanyName, c.ContactName);
}

有时，您可能需要扩展由 .NET 框架。例如，您可能需要能够按照CompanyId或CompanyName对客户集合进行排序。要实现排序，您需要定义一个实现IComparer接口的排序类。IComparer接口确保排序类用适当的签名实现了一个Compare方法。(接口在第七章中讨论过。)下面的CustomerSorter类按照CompanyName对一个Customer的列表进行排序。注意，因为CompanyName属性是一个字符串，所以可以使用字符串比较器对它们进行排序。

public class CustomerSorter : IComparer<Customer>
{
    public int Compare(Customer customer1, Customer customer2)
    {
        return customer1.CompanyName.CompareTo(customer2.CompanyName);
    }
}

现在您可以按CompanyName对客户进行排序，然后显示它们。

customerList.Sort(new CustomerSorter());

输出如图 9-9 所示。

图 9-9 。客户排序列表的控制台输出

活动 9-2。实现和扩展通用集合

在本活动中，您将熟悉以下内容:

• 实现泛型集合
• 扩展泛型集合以实现排序

要创建和填充通用列表，请遵循以下步骤:

1. 启动 Visual Studio。选择文件新建项目。

2. 选择控制台应用项目。将项目命名为 Activity9_2。

3. 选择项目添加类别。将该类文件命名为 Request.cs。

4. Add the following properties to the Request class:

   public class Request

   {

   string _requestor;

   int _priority;

   DateTime _date;

   public string Requestor

   {

   get { return _requestor; }

   set { _requestor = value; }

   }

   public int Priority

   {

   get { return _priority; }

   set { _priority = value; }

   }

   public DateTime Date

   {

   get { return _date; }

   set { _date = value; }

   }

5. Overload the constructor of the Request class to set the properties in the constructor.

   public Request(string requestor, int priority, DateTime date)

   {

   this.Requestor = requestor;

   this.Priority = priority;

   this.Date = date;

   }

6. Add a method to override the ToString method of the base Object class. This will return the request information as a string when the method is called.

   public override string ToString()

   {

   return String.Format("{0}, {1}, {2}",this.Requestor,

   this.Priority.ToString(), this.Date);

   }

7. Open the Program class in the code editor and add the following code to the Main method. This code populates a generic list of type Request and displays the values in the console window.

   static void Main(string[] args)

   {

   List<Request> reqList = new List<Request>();

   reqList.Add(new Request("Dan",2 ,new DateTime(2011,4,2)));

   reqList.Add(new Request("Alice", 5, new DateTime(2011, 2, 5)));

   reqList.Add(new Request("Bill", 3, new DateTime(2011, 6, 19)));

   foreach (Request req in reqList)

   {

   Console.WriteLine(req.ToString());

   }

   Console.ReadLine();

   }

8. 选择调试开始运行项目。控制台窗口应该启动，请求项按照添加到reqList的顺序列出。

9. 选择项目添加类。给类命名DateSorter。

10. Add the following code to the DateSorter class. This class implements the IComparer interface and is used to enable sorting requests by date.

`public class DateSorter:IComparer<Request>`

`{`

`public int Compare(Request R1, Request R2)`

`{`

`return R1.Date.CompareTo(R2.Date);`

`}`

`}`

11. Add the following code in the Main method of the Program class prior to the Console.ReadLine method. This code sorts the reqList by date and displays the values in the console window.

`Console.WriteLine("Sorted by date.");`

`reqList.Sort(new DateSorter());`

`foreach (Request req in reqList)`

`{`

`Console.WriteLine(req.ToString());`

`}`

12. Select Debug Start to run the project. The console window should launch with the output shown in Figure 9-10. After viewing the output, stop the debugger and exit Visual Studio.

![9781430249351_Fig09-10.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig09-10.jpg)

图 9-10 。未排序和按日期排序的通用集合

使用堆栈和队列编程

编程中经常使用的两种特殊类型的集合是堆栈和队列。堆栈是后进先出的对象集合。队列代表先进先出的对象集合。

栈是一个很好的方法来维护一个国际象棋游戏中的移动列表。当用户想要撤销他的移动时，他从他最近的移动开始，这是最后一个添加到列表中的移动，也是第一个检索到的移动。使用堆栈的另一个例子发生在程序执行一系列方法调用时。堆栈维护方法的地址，执行以调用方法的相反顺序返回方法。将项目放入堆栈时，使用push方法。 pop方法从堆栈中移除项目。peek方法返回堆栈顶部的对象，但不移除它。下面的代码演示如何在堆栈中添加和移除项。在这种情况下，您使用泛型来实现一堆ChessMove对象。RecordMove方法将最近的移动添加到堆栈中。GetLastMove方法返回堆栈上最近的移动。

Stack<ChessMove> moveStack = new Stack<ChessMove>();
void RecordMove(ChessMove move)
{
   moveStack.Push(move);
}
   ChessMove GetLastMove()
{
   return moveStack.Pop();
}

为帮助台请求提供服务的应用是何时使用队列的一个很好的例子。集合维护发送到应用的帮助台请求列表。当从集合中检索请求进行处理时，中的第一个请求应该是最先检索到的请求。Queue类使用enqueue和dequeue方法来添加和移除项目。它还实现了peek方法来返回队列开头的项，而不删除该项。下面的代码演示了在PaymentRequest队列中添加和删除项目。AddRequest方法将请求添加到队列中，而GetNextRequest方法将请求从队列中移除。

Queue<PaymentRequest> payRequest = new Queue<PaymentRequest>();
void AddRequest(PaymentRequest request)
{
   payRequest.Enqueue(request);
}
PaymentRequest GetNextRequest()
{
   return payRequest.Dequeue();
}

活动 9-3。实现堆栈和队列

在本活动中，您将熟悉以下内容:

• 实现堆栈集合
• 实现队列集合

要创建和填充通用列表，请遵循以下步骤:

1. 启动 Visual Studio。选择文件新建项目。

2. 选择控制台应用项目。将项目命名为活动 9_3。

3. Add the following code to the Main method of the Program class.This code creates a stack of strings and loads it with strings representing moves in a game. It then uses the Peek method to write out the move stored at the top of the stack to the console window.

   Stack<string> moveStack = new Stack<string>();

   Console.WriteLine("Loading Stack");

   for (int i = 1; i <= 5; i++)

   {

   moveStack.Push("Move " + i.ToString());

   Console.WriteLine(moveStack.Peek().ToString());

   }

4. Add the following code to the Main method of the Program class after the code in step 3. This code removes the moves from the stack using the Pop method and writes them to the console window.

   Console.WriteLine("Press the enter key to unload the stack.");

   Console.ReadLine();

   for (int i = 1; i <= 5; i++)

   {

   Console.WriteLine(moveStack.Pop().ToString());

   }

   Console.ReadLine();

5. Select Debug Start to run the project. The console window should launch with the output shown in Figure 9-11. Notice the last-in, first-out pattern of the stack. After viewing the output, stop the debugger.

   

   图 9-11 。堆栈的后进先出模式

6. Comment out the code entered in steps 3 and 4. Add the following code to the Main method of the Program class. This code creates a queue of strings and loads it with strings representing requests to a consumer help line. It then uses the Peek method to write out the request stored at the beginning of the queue of to the console window.

   Queue<string> requestQueue = new Queue<string>();

   Console.WriteLine("Loading Queue");

   for (int i = 1; i <= 5; i++)

   {

   requestQueue.Enqueue("Request " + i.ToString());

   Console.WriteLine(requestQueue.Peek().ToString());

   }

7. Add the following code to the Main method of the Program class after the code in step 6. This code removes the requests from the queue using the Dequeue method and writes them to the console window.

   Console.WriteLine("Press the enter key to unload the queue.");

   Console.ReadLine();

   for (int i = 1; i <= 5; i++)

   {

   Console.WriteLine(requestQueue.Dequeue().ToString());

   }

   Console.ReadLine();

8. Select Debug Start to run the project. The console window should launch with the output shown in Figure 9-12. Notice that as the queue is loaded the first request stays at the top of the queue. Also notice the first-in, first-out pattern of the queue. After viewing the output, stop the debugger and exit Visual Studio.

   

   图 9-12 。队列的先进先出模式

摘要

在本章中，您研究了由 .NET 框架。您学习了如何使用数组、数组列表、队列、堆栈和泛型集合。

本章是向您介绍各种 OOP 结构(如类、继承和多态)的系列文章的最后一章。您应该对 C# 中的类结构、对象协作和集合是如何实现的有一个很好的理解。已经向您介绍了 Visual Studio IDE，并且您已经练习了使用它。现在，您已经准备好将这些部分放在一起，开发一个可工作的应用。

第十章是你将发展的系列中的第一章 .NET 应用。在此过程中，您将使用 ADO.NET 和实体框架调查数据访问；使用 Windows 演示基础(WPF)和新的 Windows 8 应用商店创建基于 Windows 的 GUI 使用 web 窗体和 ASP 创建基于 Web 的 GUI。网；，并使用 ASP.NET 通信基金会(WCF)和 web API 创建 Web 服务。

十、实现数据访问层

在过去的几章中，您已经了解了各种面向对象的编程结构，如类、继承和多态，因为它们是在 C# 代码中实现的。已经向您介绍并练习了如何使用 Visual Studio 集成开发环境。您还应该对类结构和对象协作是如何实现的有一个牢固的理解。

现在，您已经准备好将这些部分放在一起，开发一个可工作的应用。因为大多数业务应用都涉及处理和更新后端关系数据库中的数据，所以您将看到 .NET Framework 提供了处理关系数据的功能。

读完本章后，你将理解以下内容:

• 如何使用Connection对象建立到数据库的连接
• 如何使用一个Command对象来执行 SQL 查询
• 如何使用一个Command对象来执行存储过程
• 如何用DataReader对象检索记录
• 如何填充数据表和数据集
• 如何在数据集中的表之间建立关系
• 如何编辑和更新数据集中的数据
• 如何创建实体数据模型
• 如何使用语言集成查询(LINQ)到实体框架(EF)来查询数据
• 如何使用实体框架更新数据

介绍 ADO.NET

为企业开发的大多数应用都需要与数据存储设备进行交互。数据存储可以以多种不同的形式出现:例如，在平面文件系统中，许多传统的大型机系统就是这种情况；或者在关系数据库管理系统中，如 SQL Server、Oracle 或 MySQL。您还可以在分层的文本文件结构中维护数据，如 XML。为了在这些不同的数据存储区中以一致的方式访问和使用数据 .NET Framework 提供了一组组织到System.Data名称空间中的类。这个类的集合被称为 ADO.NET。

回顾微软数据访问技术的历史，可以发现从连接模式到非连接模式的演变。在开发 20 世纪 80 年代和 90 年代早期流行的传统两层客户机-服务器应用时，打开与数据库的连接，使用实现服务器端游标的数据，并在处理完数据后关闭连接通常会更有效。这种方法的问题在 20 世纪 90 年代后期变得很明显，因为公司试图将其数据驱动的应用从传统的两层客户端-服务器应用发展到多层基于 web 的模型:打开并保持连接直到处理完成是不可伸缩的。可伸缩性是指应用在不明显降低性能的情况下处理数量不断增加的并发客户端的能力。微软将 ADO.NET 设计成高度可伸缩的。为了实现可伸缩性，微软围绕一个断开的模型设计了 ADO.NET。与数据库建立连接，在本地检索和缓存数据和元数据，然后关闭连接。

在此期间开发的传统数据访问技术的另一个问题是缺乏互操作性。具有高度互操作性的系统可以很容易地来回交换数据，而不管各种系统的实现技术如何。传统的数据访问技术依赖于专有的数据交换方法。使用这些技术，对于使用 Microsoft 技术(如 ADO(pre-1)构建的系统来说是很困难的 .NET)和 DCOM 与使用 Java 技术(如 JDBC 和 CORBA)构建的系统交换数据。整个行业都意识到，为不同系统之间的数据交换开发开放标准符合各方的最佳利益。微软已经接受了这些标准，并将对这些标准的支持纳入了 .NET 框架。

使用数据提供者

要建立到一个数据源的连接，比如一个 SQL Server 数据库，并处理它的数据，必须使用适当的 .NET 提供程序类。SQL Server 提供程序类位于System.Data.SqlClient名称空间中。还存在其他数据提供者，比如位于System.Data.OleDb名称空间中的 OleDb data provider for Oracle classes。这些提供程序中的每一个都实现了一个相似的类结构，您可以用它来与预期的数据源进行交互。表 10-1 总结了System.Data.SqlClient提供者名称空间的主要类。

表 10-1。系统中的类。Data.SqlClient 命名空间

班级	责任
SqlConnection	与数据库建立连接和唯一会话。
SqlCommand	表示要在数据库中执行的 Transact-SQL 语句或存储过程。
SqlDataReader	提供从数据库中读取只进行流的方法。
SqlDataAdapter	填充数据集并将更改更新回数据库。
SqlParameter	表示用于在存储过程之间传递信息的参数。
SqlTransaction	表示要在数据库中进行的 Transact-SQL 事务。
SqlError	收集与数据库服务器返回的警告或错误相关的信息。
SqlException	定义当数据库服务器返回警告或错误时引发的异常。

类似的一组类存在于System.Data.OleDb提供者名称空间中。例如，您有一个OleDbConnection类，而不是SqlConnection类。

建立连接

从数据库中检索数据的第一步是建立一个连接，，这是使用一个基于所使用的提供者类型的Connection对象来完成的。为了建立到 SQL Server 的连接，您实例化了一个类型为SqlConnection的Connection对象。您还需要为Connection对象提供一个ConnectionString。ConnectionString由一系列分号分隔的名称-值对组成，提供连接数据库服务器所需的信息。ConnectionString通常传递的一些信息是目标服务器的名称、数据库的名称和安全信息。以下代码演示了一个用于连接到 SQL Server 数据库的ConnectionString:

"Data Source=TestServer;Initial Catalog=Pubs;User ID=Dan;Password=training"

您需要通过 ConnectionString 提供的属性取决于您使用的数据提供程序。下面的代码演示了一个 ConnectionString，该 ConnectionString 使用用于 Access 的 OleDb 访问接口连接到 Access 数据库:

"Provider=Microsoft.Jet.OleDb.4.0;Data Source=D:\Data\Northwind.mdb"

下一步是调用Connection对象的Open方法。这将导致Connection对象加载适当的驱动程序并打开到数据源的连接。一旦连接打开，您就可以处理数据了。完成与数据库的交互后，调用Connection对象的Dispose方法很重要，因为当Connection对象超出范围或被垃圾收集时，连接不会被隐式释放。以下代码演示了在 SQL Server 中打开与 Pubs 数据库的连接、处理数据以及释放连接的过程:

SqlConnection pubConnection = new SqlConnection();
string connString;
try
{
    connString = "Data Source=drcsrv01;Initial Catalog=pubs;Integrated Security=True";
    pubConnection.ConnectionString = connString;
    pubConnection.Open();
    //work with data
}
catch (SqlException ex)
{
    throw ex;
}
finally
{
    pubConnection.Dispose();
}

C# 提供了一个using语句来帮助确保连接被关闭，资源被正确处理。当执行离开using语句的范围时，连接会自动关闭，连接对象会被高效地处理掉。前面的代码可以重写以利用using语句，如下所示:

string connString = "Data Source=drcsrv01;Initial Catalog=pubs;Integrated Security=True";
using(SqlConnection pubConnection = new SqlConnection())
{
    try
    {
        pubConnection.ConnectionString = connString;
        pubConnection.Open();
        //work with data
    }
    catch (SqlException ex)
    {
        throw ex;
    }
}

执行命令

一旦应用建立并打开了与数据库的连接，就可以对其执行 SQL 语句。一个Command对象存储并执行针对数据库的命令语句。您可以使用Command对象来执行数据存储理解的任何有效的 SQL 语句。对于 SQL Server，这些语句可以是数据操作语言语句(Select、Insert、Update 和 Delete)、数据定义语言语句(Create、Alter 和 Drop)或数据控制语言语句(Grant、Deny 和 Revoke)。Command对象的CommandText属性保存将要提交的 SQL 语句。根据返回的内容，Command对象包含三种向数据库提交 CommandText的方法。如果记录被返回，就像执行Select语句的情况一样，那么您可以使用ExecuteReader。如果返回单个值——例如，Select Count聚合函数的结果——您应该使用ExecuteScalar方法。当查询没有返回记录时——例如，从Insert语句中——您应该使用ExecuteNonQuery方法。下面的代码演示了如何使用一个Command对象对 Pubs 数据库执行一条 SQL 语句，返回雇员的数量。注意嵌套的using子句的使用，一个用于连接，一个用于命令。

public int GetEmployeeCount()
{
    string connString = "Data Source=drcsrv01;Initial Catalog=pubs;Integrated Security=True";

    using (SqlConnection pubConnection = new SqlConnection())
    {
        using (SqlCommand pubCommand = new SqlCommand())
        {
             try
             {
                    pubConnection.ConnectionString = connString;
                    pubConnection.Open();
                    pubCommand.Connection = pubConnection;
                    pubCommand.CommandText = "Select Count(emp_id) from employee";
                    return (int)pubCommand.ExecuteScalar();
             }
             catch (SqlException ex)
            {
                    throw ex;
            }
        }
    }
}

使用存储过程

在许多应用设计中，客户端必须执行存储过程，而不是直接执行 SQL 语句。存储过程是封装数据库逻辑、提高可伸缩性和增强多层应用安全性的一种极好的方式。要执行一个存储过程，可以使用一个Command对象，将其CommandType属性设置为StoredProcedure，将其CommandText属性设置为存储过程的名称。下面的代码执行一个存储过程，返回 Pubs 数据库中的雇员人数:

public int GetEmployeeCount()
{
    string connString = "Data Source=drcsrv01;Initial Catalog=pubs;Integrated Security=True";

    using (SqlConnection pubConnection = new SqlConnection())
    {
        using (SqlCommand pubCommand = new SqlCommand())
        {
            try
            {
                pubConnection.ConnectionString = connString;
                pubConnection.Open();
                pubCommand.Connection = pubConnection;
                pubCommand.CommandType = CommandType.StoredProcedure;
                pubCommand.CommandText = "GetEmployeeCount";
                return (int)pubCommand.ExecuteScalar();
            }
            catch (SqlException ex)
            {
                throw ex;
            }
        }
    }
}

执行存储过程时，通常必须提供输入参数。您可能还需要通过输出参数来检索存储过程的结果。要使用参数，您需要实例化一个类型为SqlParameter的参数对象，然后将其添加到Command对象的Parameters集合中。构造参数时，需要提供参数名称和 SQL Server 数据类型。对于某些数据类型，还需要提供大小。如果参数是输出、输入输出或返回参数，则必须指示参数方向。以下示例调用接受字母输入参数的存储过程。该过程返回姓氏以给定字母开头的雇员数。计数以输出参数的形式返回。

public int GetEmployeeCount(string lastInitial)
{
    string connString = "Data Source=drcsrv01;Initial Catalog=pubs;Integrated Security=True";
    using (SqlConnection pubConnection = new SqlConnection(connString))
    {
        using (SqlCommand pubCommand = new SqlCommand())
        {
            try
            {
                pubConnection.Open();
                pubCommand.Connection = pubConnection;
                pubCommand.CommandText = "GetEmployeeCountByLastInitial";
                SqlParameter inputParameter = pubCommand.Parameters.Add
                      ("@LastInitial", SqlDbType.NChar, 1);
                inputParameter.Value = lastInitial.ToCharArray()[0];
                SqlParameter outputParameter = pubCommand.Parameters.Add
                     ("@EmployeeCount", SqlDbType.Int);
                outputParameter.Direction = ParameterDirection.Output;
                pubCommand.CommandType = CommandType.StoredProcedure;
                pubCommand.ExecuteNonQuery();
                return (int)outputParameter.Value;
            }
            catch (SqlException ex)
            {
                 throw ex;
            }
        }
    }
}

使用 DataReader 对象检索数据

一个DataReader对象通过一个只进、只读的流访问数据。通常，您会希望遍历一组记录并按顺序处理结果，而不需要在缓存中维护数据。这方面的一个很好的例子是用数据库返回的值加载一个列表或数组。在声明了一个类型为SqlDataReader的对象后，通过调用一个Command对象的ExecuteReader方法来实例化它。DataReader对象的Read方法访问返回的记录。在处理完记录后，调用DataReader对象的Close方法。以下代码演示了如何使用DataReader对象从 SQL Server 数据库中检索姓名列表并将其返回给客户端:

public ArrayList ListNames()
{
    string connString = "Data Source=LocalHost;Initial Catalog=pubs;Integrated Security=True";
    using (SqlConnection pubConnection = new SqlConnection(connString))
    {
        using (SqlCommand pubCommand = new SqlCommand())
        {
            try
            {
                pubConnection.ConnectionString = connString;
                pubConnection.Open();
                pubCommand.Connection = pubConnection;
                pubCommand.CommandText =
                    "Select lname from employee";
                using (SqlDataReader employeeDataReader = pubCommand.ExecuteReader())
                {
                    ArrayList nameArray = new ArrayList();
                    while (employeeDataReader.Read())
                    {
                        nameArray.Add(employeeDataReader["lname"]);
                    }
                    return nameArray;
                }
            }
            catch (SqlException ex)
            {
                throw ex;
            }
        }
    }
}

使用 DataAdapter 检索数据

在许多情况下，您需要从数据库中检索一组数据，处理这些数据，并将对数据的任何更新返回给数据库。在这种情况下，您使用一个DataAdapter作为数据源和数据的内存缓存之间的桥梁。这种数据的内存缓存包含在独立的 DataTable 或 DataSet 中，DataSet 是 DataTable 的集合。

注意DataTable和DataSet对象将在“使用数据表和数据集”一节中详细讨论。

要从数据库中检索一组数据，首先要实例化一个DataAdapter对象。然后将DataAdapter的SelectCommand属性设置为现有的Command对象。最后，执行Fill方法，传递要填充的DataSet对象的名称。如果调用 fill 方法时 connection 对象没有打开，则它会打开以检索数据，然后关闭。如果调用 fill 方法时它是打开的，则在检索数据后它将保持打开状态。在这里，您将看到如何使用一个DataAdapter来填充一个DataTable并将DataTable传递回客户端:

public DataTable GetEmployees()
{
    string connString = "Data Source=LocalHost;Initial Catalog=pubs;Integrated Security=True";
    using (SqlConnection pubConnection = new SqlConnection(connString))
    {
        using (SqlCommand pubCommand = new SqlCommand())
        {
            pubCommand.Connection = pubConnection;
            pubCommand.CommandText = "Select emp_id, lname, Hire_Date from employee";
            using (SqlDataAdapter employeeAdapter = new SqlDataAdapter())
            {
                employeeAdapter.SelectCommand = pubCommand;
                DataTable employeeDataTable = new DataTable();
                employeeAdapter.Fill(employeeDataTable);
                return employeeDataTable;
            }
        }
    }
}

您可能会发现，与传入 SQL 语句相比，您需要通过执行存储过程来检索一组数据。下面的代码演示如何执行接受输入参数并返回一组记录的存储过程。记录被加载到一个DataSet对象中并返回给客户端。

public DataSet GetEmployees(string lastInitial)
{
    string connString = "Data Source=LocalHost;Initial Catalog=pubs;Integrated Security=True";
     using (SqlConnection pubConnection = new SqlConnection(connString))
    {
        using (SqlCommand pubCommand = new SqlCommand())
        {
             pubCommand.Connection = pubConnection;
             pubCommand.CommandText = "Select emp_id, lname, Hire_Date from employee";
             pubCommand.CommandText = "GetEmployeesByLastInitial";
             SqlParameter inputParameter = pubCommand.Parameters.Add
                 ("@LastInitial", SqlDbType.NChar, 1);
             inputParameter.Value = lastInitial.ToCharArray()[0];
             pubCommand.CommandType = CommandType.StoredProcedure;
             using (SqlDataAdapter employeeAdapter = new SqlDataAdapter())
             {
                 employeeAdapter.SelectCommand = pubCommand;
                 DataSet employeeDataSet = new DataSet();
                 employeeAdapter.Fill(employeeDataSet);
                return employeeDataSet;
            }
        }
    }
}

活动 10-1。从 SQL SERVER 数据库中检索数据

在本活动中，您将熟悉以下内容:

• 建立与 SQL Server 数据库的连接
• 通过一个Command对象执行查询
• 使用DataReader对象检索数据
• 使用Command对象执行存储过程

注意要完成本章中的活动，您必须能够访问安装了 Microsoft Pubs 和 Northwind 示例数据库的 SQL Server 2005 或更高版本的数据库服务器。您必须使用被授予访问这些数据库的适当权限的 Windows 帐户登录。根据您的设置，您可能需要更改ConnectionString。有关更多信息，请参考简介和附录 c 中的“软件要求”一节。

创建连接并执行 SQL 查询

要创建连接并执行 SQL 查询，请按照下列步骤操作:

1. 启动 Visual Studio。选择文件新建项目。

2. 选择控制台应用项目。将项目命名为Activity10_1。

3. 项目打开后，向名为Author的项目添加一个新类。

4. Open the Author class code in the code editor. Add the following using statements at the top of the file:

   using System.Data;

   using System.Data.SqlClient;

5. Add code to declare a private class-level variable containing the connection string:

   class Author

   {

   string _connString = "Data Source=localhost;Initial Catalog=pubs;Integrated Security=True";

6. Add a method to the class that will use a Command object to execute a query to count the number of authors in the Authors table. Because you are only returning a single value, you will use the ExecuteScalar method of the Command object.

   public int CountAuthors()

   {

   using (SqlConnection pubConnection = new SqlConnection(_connString))

   {

   using (SqlCommand pubCommand = new SqlCommand())

   {

   pubCommand.Connection = pubConnection;

   pubCommand.CommandText = "Select Count(au_id) from authors";

   pubConnection.Open();

   return (int)pubCommand.ExecuteScalar();

   }

   }

   }

7. Add the following code to the Main method of the Program class, which will execute the GetAuthorCount method defined in the Author class:

   static void Main(string[] args)

   {

   try

   {

   Author author = new Author();

   Console.WriteLine(author.CountAuthors());

   Console.ReadLine();

   }

   catch (Exception ex)

   {

   Console.WriteLine(ex.Message);

   Console.ReadLine();

   }

   }

8. 选择调试开始运行项目。控制台窗口应该会启动，并显示作者的数量。查看输出后，停止调试器。

使用 DataReader 对象检索记录

要使用DataReader对象来检索记录，请遵循以下步骤:

1. 在代码编辑器中打开Author类代码。

2. Add a public method to the class definition called GetAuthorList that returns a generic List of strings.

   public List<string> GetAuthorList()

   {

   }

3. Add the following code, which executes a SQL Select statement to retrieve the authors’ last names. A DataReader object then loops through the records and creates a list of names that gets returned to the client.

   List<string> nameList = new List<string>();

   using (SqlConnection pubConnection = new SqlConnection(_connString))

   {

   using (SqlCommand authorsCommand = new SqlCommand())

   {

   authorsCommand.Connection = pubConnection;

   authorsCommand.CommandText = "Select au_lname from authors";

   pubConnection.Open();

   using (SqlDataReader authorDataReader = authorsCommand.ExecuteReader())

   {

   while (authorDataReader.Read() == true)

   {

   nameList.Add(authorDataReader.GetString(0));

   }

   return nameList;

   }

   }

   }

4. Change the code in the Main method of the Program class to show the list of names in the console window.

   static void Main(string[] args)

   {

   try

   {

   Author author = new Author();

   foreach (string name in author.GetAuthorList())

   {

   Console.WriteLine(name);

   }

   Console.ReadLine();

   }

   catch (Exception ex)

   {

   Console.WriteLine(ex.Message);

   Console.ReadLine();

   }

   }

5. 选择调试开始运行项目。控制台窗口应该会启动，并显示作者的姓名。查看输出后，停止调试器。

使用命令对象执行存储过程

要使用Command对象执行存储过程，请遵循以下步骤:

1. 在代码编辑器中打开Author类代码。

2. Add a public method that overloads the GetAuthorList method by accepting an integer parameter named Royalty. This function will call the stored procedure by royalty in the Pubs database. The procedure takes an integer input of the royalty percentage and returns a list of author IDs with the percentage.

   public List<string> GetAuthorList(int royalty)

   {

   List<string> nameList = new List<string>();

   using (SqlConnection pubConnection = new SqlConnection(_connString))

   {

   using (SqlCommand authorsCommand = new SqlCommand())

   {

   authorsCommand.Connection = pubConnection;

   authorsCommand.CommandType = CommandType.StoredProcedure;

   authorsCommand.CommandText = "byroyalty";

   SqlParameter inputParameter = new SqlParameter();

   inputParameter.ParameterName = "@percentage";

   inputParameter.Direction = ParameterDirection.Input;

   inputParameter.SqlDbType = SqlDbType.Int;

   inputParameter.Value = royalty;

   authorsCommand.Parameters.Add(inputParameter);

   pubConnection.Open();

   using (SqlDataReader authorDataReader = authorsCommand.ExecuteReader())

   {

   while (authorDataReader.Read() == true)

   {

   nameList.Add(authorDataReader.GetString(0));

   }

   }

   return nameList;

   }

   }

   }

3. In the Main method of the Program class, supply an input parameter of 25 to the GetAuthorList method.

   foreach (string name in author.GetAuthorList(25))

4. 选择调试开始运行项目。控制台窗口应该启动，并显示作者的 id。查看输出后，停止调试器。

5. 完成测试后，退出 Visual Studio。

使用数据表和数据集

数据表和数据集是数据的内存缓存，提供一致的关系编程模型来处理数据，而不管数据源是什么。数据表代表一个关系数据表，由列、行和约束组成。您可以将数据集视为一个小型关系数据库，它包括数据表和它们之间的关系完整性约束。如果从单个表中检索数据，可以直接填充和使用 DataTable，而无需先创建数据集。创建数据表或数据集有几种方法。最明显的方法是从现有的关系数据库管理系统(RDBMS )(如 SQL Server 数据库)中填充 DataTable 或 DataSet。如前所述，DataAdapter对象提供了 RDBMS 和数据表或数据集之间的桥梁。通过使用一个DataAdapter对象，数据表或数据集完全独立于数据源。尽管您需要使用一组特定的提供者类来加载任一类型的对象，但是您使用相同的一组 .NET Framework 类来处理数据表或数据集，而不管它是如何创建和填充的。System.Data名称空间包含处理数据表或数据集对象的框架类。表 10-2 列出了一些包含在System.Data名称空间中的主要类。

表 10-2。系统的主要成员。数据命名空间

班级	描述
DataSet	表示一组DataTable和DataRelation对象。组织关系数据的内存缓存。
DataTable	代表一个由DataColumn、DataRow和Constraint对象组成的集合。组织与数据实体相关的记录和字段。
DataColumn	表示DataTable中某一列的模式。
DataRow	代表DataTable中的一行数据。
Constraint	表示可以在DataColumn对象上实施的约束。
ForeignKeyConstraint	在两个DataTable对象之间实施父/子关系的参照完整性。
UniqueConstraint	强制一个DataColumn或一组DataColumns的唯一性。这是在父/子关系中实施参照完整性所必需的。
DataRelation	表示两个DataTable对象之间的父/子关系。

从 SQL Server 数据库填充数据表

要从数据库中检索数据，需要使用一个Connection对象建立与数据库的连接。建立连接后，创建一个Command对象从数据库中检索数据。如前所述，如果您从单个表或结果集中检索数据，您可以直接填充并使用DataTable,而无需创建DataSet对象。DataTable的 Load 方法用一个DataReader对象的内容填充表格。下面的代码用 Pubs 数据库的 publishers 表中的数据填充了一个DataTable:

public DataTable GetPublishers()
{
    string connString = "Data Source=drcsrv01;" +
         "Initial Catalog=pubs;Integrated Security=True";
    DataTable pubTable;
    using (SqlConnection pubConnection = new SqlConnection(connString))
    {
        using (SqlCommand pubCommand = new SqlCommand())
        {
             pubCommand.Connection = pubConnection;
             pubCommand.CommandText =
                 "Select pub_id, pub_name, city from publishers";
             pubConnection.Open();
             using (SqlDataReader pubDataReader = pubCommand.ExecuteReader())
            {
                pubTable = new DataTable();
                pubTable.Load(pubDataReader);
                return pubTable;
            }
        }
    }
}

从 SQL Server 数据库填充数据集

当您需要将数据加载到多个表中并维护表之间的引用完整性时，您需要使用DataSet对象作为DataTables的容器。为了从数据库中检索数据并填充DataSet，使用Connection对象建立与数据库的连接。建立连接后，创建一个Command对象从数据库中检索数据，然后创建一个DataAdapter来填充DataSet，将之前创建的Command对象设置为DataAdapter的SelectCommand属性。为每个DataTable创建一个单独的DataAdapter。最后一步是通过执行DataAdapter的Fill方法用数据填充DataSet。下面的代码演示了用 Pubs 数据库的 publishers 表和 titles 表中的数据填充一个DataSet:

public DataSet GetPubsDS()
{
    string connString = "Data Source=Localhost;" +
         "Initial Catalog=pubs;Integrated Security=True";
    DataSet bookInfoDataSet= new DataSet();
    using (SqlConnection pubConnection = new SqlConnection(connString))
    {
        //Fill pub table
        using (SqlCommand pubCommand = new SqlCommand())
        {
            pubCommand.Connection = pubConnection;
            pubCommand.CommandText =
                "Select pub_id, pub_name, city from publishers";
            using (SqlDataAdapter pubDataAdapter = new SqlDataAdapter())
            {
                pubDataAdapter.SelectCommand = pubCommand;
                pubDataAdapter.Fill(bookInfoDataSet, "Publishers");
            }
        }
        //Fill title table
        using (SqlCommand titleCommand = new SqlCommand())
        {
            titleCommand.Connection = pubConnection;
            titleCommand.CommandText =
                "Select pub_id, title, ytd_sales from titles";
            using (SqlDataAdapter titleDataAdapter = new SqlDataAdapter())
            {
                titleDataAdapter.SelectCommand = titleCommand;
                titleDataAdapter.Fill(bookInfoDataSet, "Titles");
            }
        }
        return bookInfoDataSet;
    }
}

在数据集中的表之间建立关系

在 RDBMS 系统中，表之间的引用完整性是通过主键和外键关系来实现的。使用一个DataRelation对象，您可以在DataSet中的表之间实施数据引用完整性。该对象包含一个DataColumn对象数组，这些对象定义了父表和子表之间用于建立关系的公共字段。本质上，父表中标识的字段是主键，子表中标识的字段是外键。建立关系时，为每个表中的公共列创建两个DataColumn对象。接下来，创建一个DataRelation对象，为DataRelation、传递一个名称，并将DataColumn对象传递给DataRelation对象的构造函数。最后一步是将DataRelation添加到DataSet对象的Relations集合中。下面的代码在出版商和上一节中创建的bookInfoDataSet的标题表之间建立了一个关系:

//Create relationahip between tables
DataRelation Pub_TitleRelation;
DataColumn Pub_PubIdColumn;
DataColumn Title_PubIdColumn;
Pub_PubIdColumn = bookInfoDataSet.Tables["Publishers"].Columns["pub_id"];
Title_PubIdColumn = bookInfoDataSet.Tables["Titles"].Columns["pub_id"];
Pub_TitleRelation = new DataRelation("PubsToTitles", Pub_PubIdColumn, Title_PubIdColumn);
bookInfoDataSet.Relations.Add(Pub_TitleRelation);

编辑数据集中的数据

客户端通常需要能够更新数据集。他们可能需要添加记录、删除记录或更新现有记录。因为数据集对象在设计上是断开连接的，所以对数据集所做的更改不会自动传播回数据库。它们保存在本地，直到客户机准备好将更改复制回数据库。要复制更改，您需要调用DataAdapter的Update方法，该方法确定对记录做了什么更改，并实现适当的 SQL 命令(Update、Insert 或 Delete ),该命令已被定义为将更改复制回数据库。

当您创建一个Update命令时，命令文本引用命令的Parameters集合中与数据表中的字段相对应的参数。

SqlCommand updateCommand  = new SqlCommand();
string updateSQL = "Update publishers set pub_name = @pub_name," +
    " city = @city where pub_id = @pub_id";
updateCommand = new SqlCommand(updateSQL, pubConnection);
updateCommand.CommandType = CommandType.Text;

对于Update语句中的每个参数，Parameter对象被添加到Command对象的Parameter集合中。向Parameters集合的Add方法传递关于参数名、SQL 数据类型、大小和数据集的源列的信息。

updateCommand.Parameters.Add("@pub_id", SqlDbType.Char, 4, "pub_id");
updateCommand.Parameters.Add("@city", SqlDbType.VarChar, 20, "city");
updateCommand.Parameters.Add("@pub_name", SqlDbType.VarChar, 40, "pub_name");

Once the parameters are created, the updateCommand object is set to the UpdateCommand property of the DataAdapter object.

pubDataAdapter.UpdateCommand = updateCommand;

现在已经设置了 SqlDataAdapter，您调用 SQLDataAdapter 的Update方法，传入DataSet和要更新的表的名称。SQLDataAdapter 检查表中行的RowState属性，并对要更新的每一行迭代执行 update 语句。

pubDataAdapter.Update(bookInfoDataSet, "Publishers");

以类似的方式，您可以实现DataAdapter的InsertCommand和DeleteCommand属性，以允许客户端在数据库中插入新记录或删除记录。

注意对于数据源中单个表的简单更新 .NET 框架提供了一个CommandBuilder类来自动创建DataAdapter的InsertCommand、UpdateCommand和DeleteCommand属性。

活动 10-2。使用数据集对象

在本活动中，您将熟悉以下内容:

• 从 SQL Server 数据库填充一个DataSet
• 编辑DataSet中的数据
• 将更改从DataSet更新到数据库
• 在DataSet中建立表之间的关系

从 SQL Server 数据库填充数据集

要从 SQL Server 数据库填充一个DataSet，请执行以下步骤:

1. 启动 Visual Studio。选择文件新建项目。

2. 选择 Windows 窗体应用。将项目重命名为 Activity10_2，然后单击“确定”按钮。

3. 项目打开后，向名为Author的项目添加一个新类。

4. Open the Author class code in the code editor. Add the following using statements at the top of the file:

   using System.Data;

   using System.Data.SqlClient;

5. Add the following code to declare a private class level variable for the connection string.

   class Author

   {

   string _connString = "Data Source=localhost;" + "Initial Catalog=pubs;Integrated Security=True";

6. Create a method of the Author class called GetData that will use a DataAdapter object to fill the DataSet and return it to the client.

   public DataSet GetData()

   {

   DataSet authorDataSet;

   using (SqlConnection pubConnection = new SqlConnection())

   {

   pubConnection.ConnectionString = _connString;

   using(SqlCommand selectCommand = new SqlCommand())

   {

   selectCommand.CommandText = "Select au_id, au_lname,au_fname from authors";

   selectCommand.Connection = pubConnection;

   using (SqlDataAdapter pubDataAdapter = new SqlDataAdapter())

   {

   pubDataAdapter.SelectCommand = selectCommand;

   authorDataSet = new DataSet();

   pubDataAdapter.Fill(authorDataSet, "Author");

   }

   }

   return authorDataSet;

   }

7. 构建项目并修复任何错误。

8. Add the controls listed in Table 10-3 to Form1 and set the properties as shown.

   表 10-3。表格 1 控件

   控制	财产	价值
   DataGridView	Name	dgvAuthors
   	AllowUserToAddRows	False
   	AllowUserToDeleteRows	False
   	ReadOnly	False
   Button	Name	btnGetData
   	Text	Get Data
   Button	Name	btnUpdate
   	Text	Update

9. Open the Form1 class code file in the code editor. Declare a class-level DataSet object after the class declaration.

   public partial class Form1 : Form

   {

   private DataSet _pubDataSet;

10. 在窗体设计器中打开 Form1。双击“获取数据”按钮，在代码编辑器中打开按钮单击事件方法。

11. Add the following code to the btnGetData click event procedure, which will execute the GetData method defined in the Author class. This dataset is then loaded into the grid using the DataSource property.

`private void btnGetData_Click(object sender, EventArgs e)`

`{`

`Author author = new Author();`

`_pubDataSet = author.GetData();`

`dgvAuthors.DataSource = _pubDataSet.Tables["Author"];`

`}`

12. 构建项目并修复任何错误。一旦项目构建完成，在调试模式下运行项目并测试GetData方法。您应该会看到网格中充满了作者信息。测试后，停止调试器。

编辑和更新数据集中的数据

要编辑和更新DataSet中的数据，请遵循以下步骤:

1. 在代码编辑器中打开Author类代码。

2. Create a method of the Author class called UpdateData that will use the Update method of the DataAdapter object to pass updates made to the DataSet to the Pubs database.

   public void UpdateData(DataSet changedData)

   {

   using (SqlConnection pubConnection = new SqlConnection())

   {

   pubConnection.ConnectionString = _connString;

   using (SqlCommand updateCommand = new SqlCommand())

   {

   updateCommand.CommandText = "Update authors set au_lname = @au_lname," +

   "au_fname = @au_fname where au_id = @au_id";

   updateCommand.Parameters.Add ("@au_id", SqlDbType.VarChar, 11, "au_id");

   updateCommand.Parameters.Add ("@au_lname", SqlDbType.VarChar, 40, "au_lname");

   updateCommand.Parameters.Add ("@au_lname", SqlDbType.VarChar, 40, "au_lname");

   updateCommand.Connection = pubConnection;

   using (SqlDataAdapter pubDataAdapter = new SqlDataAdapter())

   {

   pubDataAdapter.UpdateCommand = updateCommand;

   pubDataAdapter.Update(changedData, "Author");

   }

   }

   }

   }

3. 构建项目并修复任何错误。

4. 在表单设计器中打开Form1。双击“更新数据”按钮，在代码编辑器中打开按钮 click 事件方法。

5. Add the following code to the btnUpdate click event procedure, which will execute the UpdateData method defined in the Author class. By using the GetChanges method of the DataSet object, only data that has changed is passed for updating.

   private void btnUpdate_Click(object sender, EventArgs e)

   {

   Author author = new Author();

   author.UpdateData(_pubDataSet.GetChanges());

   }

6. 构建项目并修复任何错误。一旦项目构建完成，在调试模式下运行项目并测试Update方法。首先，单击“获取数据”按钮。更改几个作者的姓氏，然后单击更新按钮。再次单击“获取数据”按钮，从数据库中检索已更改的值。测试后，停止调试器。

建立数据集中表格之间的关系

要在一个DataSet中建立表之间的关系，请遵循以下步骤:

1. 将名为StoreSales的新类添加到项目中。

2. Open the StoreSales class code in the code editor. Add the following using statements at the top of the file:

   using System.Data;

   using System.Data.SqlClient;

3. Add the following code to declare private class level variables for the connection string and DataSet.

   class StoreSales

   {

   string _connString = "Data Source=localhost;" + "Initial Catalog=pubs;Integrated Security=True";

4. Create a method of the StoreSales class called GetData that will select store information and sales information and establish a relationship between them. This information is used to fill a DataSet and return it to the client.

   public DataSet GetData()

   {

   DataSet storeSalesDataSet;

   storeSalesDataSet = new DataSet();

   using (SqlConnection pubConnection = new SqlConnection(_connString))

   {

   //Fill store table

   using (SqlCommand storeCommand = new SqlCommand())

   {

   storeCommand.Connection = pubConnection;

   storeCommand.CommandText =

   "SELECT [stor_id],[stor_name],[city],[state] FROM [stores]";

   using (SqlDataAdapter storeDataAdapter = new SqlDataAdapter())

   {

   storeDataAdapter.SelectCommand = storeCommand;

   storeDataAdapter.Fill(storeSalesDataSet, "Stores");

   }

   }

   //Fill sales table command

   using (SqlCommand salesCommand = new SqlCommand())

   {

   salesCommand.Connection = pubConnection;

   salesCommand.CommandText =

   "SELECT [stor_id],[ord_num],[ord_date],[qty] FROM [sales]";

   using (SqlDataAdapter salesDataAdapter = new SqlDataAdapter())

   {

   salesDataAdapter.SelectCommand = salesCommand;

   salesDataAdapter.Fill(storeSalesDataSet, "Sales");

   }

   }

   //Create relationahip between tables

   DataColumn Store_StoreIdColumn =

   storeSalesDataSet.Tables["Stores"].Columns["stor_id"];

   DataColumn Sales_StoreIdColumn =

   storeSalesDataSet.Tables["Sales"].Columns["stor_id"];

   DataRelation StoreSalesRelation = new DataRelation ("StoresToSales", Store_StoreIdColumn, Sales_StoreIdColumn);

   ``storeSalesDataSet.Relations.Add(StoreSalesRelation);`

   return storeSalesDataSet;

   }

   }`` * 构建项目并修复任何错误。* Add a second form to the project. Add the controls listed in Table 10-4 to Form2 and set the properties as shown.

   表 10-4。Form2 控件

   控制	财产	价值
   DataGridView	Name	dgvStores
   DataGridView	Name	dgvSales
   Button	Name	btnGetData
   	Text	Get Data

   • Open the Form2 class code file in the code editor. Declare a class-level DataSet object after the class declaration.

   public partial class Form2 : Form

   {

   DataSet StoreSalesDataSet;

   • 在窗体设计器中打开 Form2。双击“获取数据”按钮，在代码编辑器中打开按钮单击事件方法。* Add the following code to the btnGetData click event procedure, which will execute the GetData method defined in the StoreSales class. This Stores table is then loaded into the Stores grid using the DataSource property. Setting the DataMember property of the Sales grid loads it with the sales data of the store selected in the Stores grid.

   private void btnGetData_Click(object sender, EventArgs e)

   {

   StoreSales storeSales = new StoreSales();

   StoreSalesDataSet = storeSales.GetData();

   dgvStores.DataSource = StoreSalesDataSet.Tables["Stores"];

   dgvSales.DataSource =StoreSalesDataSet.Tables["Stores"];

   dgvSales.DataMember = "StoresToSales";

   }

   • Open the Program class in the code editor. Change the code to launch Form2 when the form loads.

   Application.Run(new Form2());

   • 表单加载后，单击“获取数据”按钮加载网格。在商店网格中选择一个新行应该会更新销售网格，以显示商店的销售额。完成测试后，停止调试器并退出 Visual Studio。`

`使用实体框架

实体框架(EF) 是内置于 ADO.NET 的对象关系映射(ORM)技术。EF 消除了 .NET 语言和数据库系统的关系数据结构。例如，要加载和使用客户对象，开发人员必须向数据库引擎发送一个 SQL 字符串。这要求开发人员熟悉数据的关系模式。此外，SQL 被硬编码到应用中，应用不会受到底层模式变化的影响。另一个缺点是，由于应用将 SQL 语句作为字符串发送到数据库引擎进行处理，Visual Studio 无法实现语法检查并发出警告和构建错误来提高程序员的工作效率。

实体框架提供了映射模式,允许程序员在更高的抽象层次上工作。他们可以使用面向对象的结构编写代码来查询和加载实体(由类定义的对象)。映射模式将针对实体的查询转换为针对数据执行 CRUD(创建、读取、更新和删除)操作所需的特定于数据库的语言。

为了在您的应用中使用实体框架，您必须首先将 ADO.NET 实体数据模型添加到您的应用中。这一步启动实体数据模型向导，，它允许您从头开始开发您的模型，或者从现有的数据库中生成它。选择从现有数据库生成它，可以创建到数据库的连接，并选择要包含在模型中的表、视图和存储过程。向导的输出是一个.edmx文件。这个文件是一个基于 XML 的文件，有三个部分。第一种由商店模式定义语言(SSDL) 组成；这描述了存储数据的表格和关系。以下代码显示了从 Pubs 数据库生成的数据模型的 SSDL 的一部分:

<EntityContainer Name="pubsModelStoreContainer">
          <EntitySet Name="sales" EntityType="pubsModel.Store.sales"
                     store:Type="Tables" Schema="dbo" />
          <EntitySet Name="stores" EntityType="pubsModel.Store.stores"
                     store:Type="Tables" Schema="dbo" />
          <AssociationSet Name="FK__sales__stor_id__1273C1CD"
                          Association="pubsModel.Store.FK__sales__stor_id__1273C1CD">
            <End Role="stores" EntitySet="stores" />
            <End Role="sales" EntitySet="sales" />
          </AssociationSet>
        </EntityContainer>
        <EntityType Name="sales">
          <Key>
            <PropertyRef Name="stor_id" />
            <PropertyRef Name="ord_num" />
            <PropertyRef Name="title_id" />
          </Key>
          <Property Name="stor_id" Type="char" Nullable="false" MaxLength="4" />
          <Property Name="ord_num" Type="varchar" Nullable="false" MaxLength="20" />
          <Property Name="ord_date" Type="datetime" Nullable="false" />
          <Property Name="qty" Type="smallint" Nullable="false" />
          <Property Name="payterms" Type="varchar" Nullable="false" MaxLength="12" />
          <Property Name="title_id" Type="varchar" Nullable="false" MaxLength="6" />
        </EntityType>

第二部分由概念图式定义语言(CSDL)；它指定了实体以及它们之间的关系。这些实体用于处理应用中的数据。以下代码来自 Pubs 数据库生成的数据模型的 CSDL 部分:

<EntityContainer Name="pubsEntities" annotation:LazyLoadingEnabled="true">
 <EntitySet Name="sales" EntityType="pubsModel.sale" />
 <EntitySet Name="stores" EntityType="pubsModel.store" />
 <AssociationSet Name="FK__sales__stor_id__1273C1CD"
                 Association="pubsModel.FK__sales__stor_id__1273C1CD">
   <End Role="stores" EntitySet="stores" />
   <End Role="sales" EntitySet="sales" />
 </AssociationSet>
</EntityContainer>
<EntityType Name="sale">
  <Key>
    <PropertyRef Name="stor_id" />
    <PropertyRef Name="ord_num" />
    <PropertyRef Name="title_id" />
  </Key>
          <Property Name="stor_id" Type="String" Nullable="false"
                    MaxLength="4" Unicode="false" FixedLength="true" />
          <Property Name="ord_num" Type="String" Nullable="false"
                    MaxLength="20" Unicode="false" FixedLength="false" />
          <Property Name="ord_date" Type="DateTime" Nullable="false" />
          <Property Name="qty" Type="Int16" Nullable="false" />
          <Property Name="payterms" Type="String" Nullable="false"
                    MaxLength="12" Unicode="false" FixedLength="false" />
          <Property Name="title_id" Type="String" Nullable="false"
                    MaxLength="6" Unicode="false" FixedLength="false" />
          <NavigationProperty Name="store"
                    Relationship="pubsModel.FK__sales__stor_id__1273C1CD"
                FromRole="sales" ToRole="stores" />
        </EntityType>

.edmx文件的最后一部分由用映射规范语言(MSL) 编写的代码组成。MSL 将概念模型映射到存储模型。以下代码显示了从 Pubs 数据库生成的数据模型的 MSL 部分的一部分:

<EntityContainerMapping StorageEntityContainer="pubsModelStoreContainer"
                                CdmEntityContainer="pubsEntities">
          <EntitySetMapping Name="sales"><EntityTypeMapping TypeName="pubsModel.sale">
            <MappingFragment StoreEntitySet="sales">
            <ScalarProperty Name="stor_id" ColumnName="stor_id" />
            <ScalarProperty Name="ord_num" ColumnName="ord_num" />
            <ScalarProperty Name="ord_date" ColumnName="ord_date" />
            <ScalarProperty Name="qty" ColumnName="qty" />
            <ScalarProperty Name="payterms" ColumnName="payterms" />
            <ScalarProperty Name="title_id" ColumnName="title_id" />
            </MappingFragment></EntityTypeMapping></EntitySetMapping>

Visual Studio 提供了一个可视化设计器来处理实体模型。使用这个设计器，你可以更新实体，添加关联，实现继承。在可视化模型中所做的更改被转换回。相应更新的 edmx 文件。图 10-1 显示了可视化设计器中从 pubs 数据库生成的实体。

图 10-1 。实体模型设计器中的实体

从 LINQ 到英孚查询实体

当使用实体数据模型向导创建 ADO.NET 实体数据模型时，会创建一个代表模型中定义的实体容器的ObjectContext类。ObjectContext类支持针对实体模型的基于 CRUD 的查询。针对ObjectContext类编写的查询是使用 LINQ 到 EF 编写的。如前所述，LINQ 代表语言集成查询。LINQ 允许开发人员用 C# 语法编写查询，当执行时，查询被转换成数据提供者的查询语法。一旦执行了查询并返回了数据，实体框架就将结果转换回实体对象模型。

下面的代码使用Select方法返回 Stores 表中的所有行，并将结果作为一列Store实体返回。商店名称随后被写入控制台窗口。

var context = new pubsEntities();
var query = from s in context.stores
            select s;
var stores = query.ToList();
foreach (store s in stores)
{
    Console.WriteLine(s.stor_name);
}
Console.ReadLine();

LINQ 到 EF 提供了一组丰富的查询操作，包括过滤、排序和分组操作。下面的代码演示了按状态过滤商店:

var context = new pubsEntities();
var query = from s in context.stores
            where  s.state == "WA"
            select s;
var stores = query.ToList();

以下代码选择订购了 25 个以上对象的销售实体，然后按降序对它们进行排序:

var context = new pubsEntities();
var query = from s in context.sales
            where s.qty > 25
            orderby s.ord_date descending
            select s;
var sales = query.ToList();

由于实体框架包括实体之间的导航属性，您可以轻松地基于相关实体构建复杂的查询。以下查询选择有五个以上销售订单的商店:

var context = new pubsEntities();
var query = from s in context.stores
            where s.sales.Count > 5
            select s;
var stores = query.ToList();

注关于 LINQ 查询语言的更多信息，请参考位于http://msdn.microsoft.com的 MSDN 图书馆。

使用实体框架更新实体

实体框架跟踪对在Context对象中表示的实体类型所做的改变。您可以添加、更新或删除实体对象。当您准备好将更改保存回数据库时，您可以调用context对象的SaveChanges方法。EF 创建并执行针对数据库的插入、更新或删除语句。您还可以显式映射存储过程来实现数据库命令。以下代码使用商店 ID 选择一个商店，更新商店名称，并将其发送回数据库:

var context = new pubsEntities();
var store = (from s in context.stores
             where s.stor_id == storeId
             select s).First();
store.stor_name = "DRC Books";
context.SaveChanges();

活动 10-3。使用实体框架检索数据

在本活动中，您将熟悉以下内容:

• 创建实体数据模型
• 使用 LINQ 到 EF 执行查询

创建实体数据模型

要创建实体数据模型，请遵循以下步骤:

1. 启动 Visual Studio。选择文件新建项目。

2. 选择控制台应用。将项目重命名为 Activity10_3，然后单击“确定”按钮。

3. 在解决方案资源管理器中右键单击项目节点，并选择 Add New Item。

4. 在“添加新项”窗口的“数据”节点下，选择一个 ADO.NET 实体数据模型。将模型命名为 Pubs.edmx，然后单击 Add。

5. 在选择模型内容屏幕中，选择从数据库生成，然后单击下一步。

6. In the Choose Your Data Connection screen, create a connection to the Pubs database and choose Next. (See Figure 10-2)

   

   图 10-2 。使用实体数据模型向导创建数据库连接

7. In the Choose Your Database Objects screen, expand the Tables node and select the Sales, Stores, and Titles tables, as shown in Figure 10-3. Click Finish.

   

   图 10-3 。为实体数据模型选择数据库对象

8. You are presented with the Entity Model Designer containing the sales, store, and title entities, as shown in Figure 10-4.

   

   图 10-4 。实体模型设计器

9. 在实体模型设计器中，右击title实体并选择重命名。改名为book。在图书实体中，将title1属性重命名为title。

查询实体数据模型

要使用 LINQ 查询该实体数据模型，请按照下列步骤操作:

1. 在代码编辑器窗口中打开 Program.cs 文件。

2. Add the following method to select the book entities and write their titles to the Console window:

   private static void GetTitles()

   {

   var context = new pubsEntities();

   var query = from b in context.books select b;

   var books = query.ToList();

   foreach (book b in books)

   {

   Console.WriteLine(b.title);

   }

   Console.ReadLine();

   }

3. Call the GetTitles method from the Main method.

   static void Main(string[] args)

   {

   GetTitles();

   }

4. 在调试模式下运行程序。您应该会看到控制台窗口中列出的标题。完成测试后，停止调试器。

5. Add the following method that gets books in the 10 to 20 dollar range and orders them by price:

   private static void GetTitlesByPrice()

   {

   var context = new pubsEntities();

   var query = from b in context.books

   where b.price >= (decimal)10.00

   && b.price <= (decimal)20.00

   orderby b.price

   select b;

   var books = query.ToList();

   foreach (book b in books)

   {

   Console.WriteLine(b.price + " -- " + b.title);

   }

   Console.ReadLine();

   }

6. Call the GetTitlesByPrice method from the Main method.

   static void Main(string[] args)

   {

   //GetTitles();

   GetTitlesByPrice();

   }

7. 在调试模式下运行程序。您应该会在控制台窗口中看到标题和价格。完成测试后，停止调试器。

8. Add the following method to list the book titles and the sum of their sales amount. Notice that this query gets the sales amount by adding up the book’s related sales entities.

   private static void GetBooksSold()

   {

   var context = new pubsEntities();

   var query = from b in context.books

   select new

   {

   BookID = b.title_id,

   TotalSold = b.sales.Sum(s =>(int?) s.qty)

   };

   foreach (var item in query)

   {

   Console.WriteLine(item.BookID + " -- " + item.TotalSold);

   }

   Console.ReadLine();

   }

9. Call the GetBooksSold method from the Main method.

   static void Main(string[] args)

   {

   //GetTitles();

   //GetTitlesByPrice();

   GetBooksSold();

   }

10. 在调试模式下运行程序。您应该会在控制台窗口中看到图书 id 和销售量。完成测试后，停止调试器并退出 Visual Studio。

摘要

本章是向您展示如何构建 OOP 应用各层的系列文章的第一章。为了实现应用的数据访问层，您学习了 about 和用于处理关系数据源的类。您看到了组成System.Data.SqlClient名称空间的各种类；这些类检索和更新存储在 SQL Server 数据库中的数据。您还研究了处理断开连接的数据的System.Data名称空间类。此外，您还接触了实体框架和 LINQ，看到了它们如何允许您使用 OOP 结构查询数据。您根据实体编写查询，框架将查询翻译成数据源的查询语法，检索数据，并加载实体。

在第十一章中，你将看到如何实现 Windows 应用的用户界面层。在这个过程中，您将进一步了解 .NET Framework 用于创建丰富的基于 Windows 的用户界面。`

十一、开发 WPF 应用

在第十章中，你学习了如何构建应用的数据访问层。为了实现它的逻辑，您使用了System.Data名称空间的类。这些类检索和处理关系数据，这是许多业务应用的常见需求。现在，您已经准备好了解用户将如何与您的应用进行交互。用户通过用户界面层与应用进行交互。这一层又与业务逻辑层交互，业务逻辑层又与数据访问层交互。在本章中，您将学习如何使用？NET Windows 演示基础(WPF)。WPF 通常用于开发在 Windows 7 及更高版本上运行的桌面业务生产力应用。商业生产力应用面向需要查询和更新存储在后端数据库中的数据的商业用户。它由一套全面的应用开发功能组成，包括可扩展应用标记语言(XAML) 、控件、数据绑定和布局。本章讨论的概念也将为第十三章奠定基础，在第十三章中，我们将着眼于为 Windows 8 创建新的 Windows Store 应用用户界面。这些应用使用类似的模型来创建具有 XAML 和数据绑定控件的界面。

阅读本章后，您将能够轻松执行以下任务:

• 使用 XAML 标记设计用户界面
• 使用布局控件
• 使用显示控件
• 响应控制事件
• 使用数据绑定控件
• 创建和使用控件模板

Windows 基础

窗口是具有可视界面的对象，绘制在屏幕上，为用户提供与程序交互的方式。像面向对象语言中的大多数对象一样 .NET 窗口公开属性、方法和事件。窗口的属性定义了它的外观。例如，它的Background属性决定了它的颜色。窗口的方法定义了它的行为。例如，调用它的Hide方法对用户隐藏它。窗口的事件定义了与用户(或其他对象)的交互。例如，当用户在窗口上单击鼠标右键时，您可以使用MouseDown事件来启动一个动作。

控件是具有可视化界面的组件，为用户提供了与程序交互的方式。窗口是一种特殊类型的控件，称为容器控件，它承载其他控件。您可以在窗口上放置许多不同类型的控件。在 windows 上使用的一些常见控件有文本框、标签、选项按钮、列表框和复选框。除了提供的控件之外 .NET Framework，您也可以创建自己的自定义控件或从第三方供应商处购买控件。

介绍 XAML

WPF 用户界面是使用一种称为 XAML 的声明性标记语言构建的。 XAML 声明组成界面的控件。左尖括号(<)后跟控件类型名称和右尖括号定义控件。例如，下面的标记在网格中定义了一个按钮控件。

```cs`

      

请注意，该网格需要一个正式的结束标记，因为它包含按钮控件。因为按钮控件不包含任何其他元素，所以可以在结束括号前使用正斜杠(`/`)来关闭它。

下一步是定义控件的属性。例如，你可能想将按钮的背景颜色设置为红色，并在上面写一些文字。使用属性语法设置控件的属性，属性语法由属性名、等号和引号中的属性值组成。以下标记显示了添加了一些属性的按钮控件:

```cs
<Grid>
      <Button Content="Click Me" Background="Red"/>
</Grid>

对于对象元素的某些属性，使用一种称为属性元素语法的语法。属性元素开始标签的语法是<typeName.propertyName>。例如，您可以在布局网格中创建行和列，以控制网格中控件的放置，如下所示:

<Grid.ColumnDefinitions>
        <ColumnDefinition Width="100" />
        <ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
        <RowDefinition Height="25" />
        <RowDefinition Height="25" />
        <RowDefinition Height="25" />
</Grid.RowDefinitions>

控件通过包含Grid.Row和Grid.Column属性、在网格中定位，如下所示:

<Label Grid.Column="0" Grid.Row="0" Content="Name:" />
        <Label Grid.Column="0" Grid.Row="1" Content="Password:" />
        <TextBox Name="txtName" Grid.Column="1"  Grid.Row="0"/>
        <TextBox Name="txtPassword" Grid.Column="1"  Grid.Row="1"/>
        <Button Grid.Column="1" Grid.Row="3"
        Content="Click Me" HorizontalAlignment="Right"
        MinWidth="80" Background="Red"/>

图 11-1 显示了由先前的 XAML 代码创建的带有两个文本框的窗口。

图 11-1 。用 XAML 创造的窗户

使用布局控件

虽然您可以使用固定位置在 WPF 窗口上放置控件，但不建议这样做。使用固定定位通常适用于固定的分辨率大小，但不适用于不同的分辨率和设备。为了克服固定定位的局限性，WPF 提供了几个布局控件。布局控件允许您使用相对定位格式在其中定位其他控件。用于定位其他控件的主要布局控件之一是网格。如前所述，一个网格控件包含列和行来控制其子控件的位置。列和行的高度和宽度可以设置为固定值、自动或*。自动设置占用所包含控件所需的空间。*设置占用尽可能多的可用空间。网格控件通常用于布局数据输入表单。下面的代码展示了一个用于收集用户信息的简单数据输入表单。结果表单(在 Visual Studio 设计器中)如图 11-2 中的所示。

图 11-2 。输入表单窗口

<Grid>
    <Grid.RowDefinitions>
        <RowDefinition Height="Auto" />
        <RowDefinition Height="Auto" />
        <RowDefinition Height="Auto" />
        <RowDefinition Height="Auto" />
        <RowDefinition Height="28" />
        <RowDefinition Height="*" />
    </Grid.RowDefinitions>
    <Grid.ColumnDefinitions>
        <ColumnDefinition Width="Auto" />
        <ColumnDefinition Width="200" />
        <ColumnDefinition Width="*" />
    </Grid.ColumnDefinitions>
    <Label Grid.Row="0" Grid.Column="0" Content="Name:"/>
    <Label Grid.Row="1" Grid.Column="0" Content="Old Password:"/>
    <Label Grid.Row="2" Grid.Column="0" Content="New Password:"/>
    <Label Grid.Row="3" Grid.Column="0" Content="Confirm Password:"/>
    <TextBox Grid.Column="1" Grid.Row="0" Margin="3" />
    <TextBox Grid.Column="1" Grid.Row="1" Margin="3" />
    <TextBox Grid.Column="1" Grid.Row="2" Margin="3" />
    <TextBox Grid.Column="1" Grid.Row="3" Margin="3" />
    <Button Grid.Column="1" Grid.Row="4" HorizontalAlignment="Right"
        MinWidth="80" Margin="0,0,0,8" Content="Submit"  />
</Grid>

另一个有用的布局控件是 StackPanel。它根据方向设置垂直或水平布局子控件。下面的代码显示了 StackPanel 控件中的两个按钮:

<StackPanel Grid.Column="1" Grid.Row="4" Orientation="Horizontal" >
    <Button  MinWidth="80" Margin="0,0,0,8" Content="Submit" />
    <Button  MinWidth="80" Margin="0,0,0,8" Content="Cancel"  />
</StackPanel>

其他一些可用的布局控件有 DockPanel、WrapPanel 和 Canvas。dock panel 用于将元素停靠在面板的左侧、右侧、顶部、底部或中心。 WrapPanel 的行为类似于 StackPanel，但是如果没有剩余空间，它会将子控件换行。画布控件用于以相对于其一侧的绝对定位来布局其子元素。它通常用于图形元素，而不是布局用户界面控件。

添加显示控件

大多数业务应用的目标是向用户呈现数据，并允许他们更新数据并将其保存回数据库。用于简化这一过程的一些常见控件有文本框、列表框、组合框、复选框、日期选择器和数据网格。您已经看到了在窗口上使用的 TextBox 下面的代码演示了如何向窗口中添加 ListBox 和 ComboBox。图 11-3 显示了窗口是如何呈现的。

图 11-3 。包含列表框和组合框的窗口

<Grid>
    <Grid.ColumnDefinitions>
        <ColumnDefinition Width="*" />
        <ColumnDefinition Width="*" />
    </Grid.ColumnDefinitions>
    <ListBox Margin="20" Grid.Column="0">
        <ListBoxItem>Red</ListBoxItem>
        <ListBoxItem>Blue</ListBoxItem>
        <ListBoxItem>Green</ListBoxItem>
        <ListBoxItem>Yellow</ListBoxItem>
    </ListBox>
    <ComboBox Grid.Column="1" VerticalAlignment="Top">
        <ComboBoxItem>Small</ComboBoxItem>
        <ComboBoxItem>Medium</ComboBoxItem>
        <ComboBoxItem>Large</ComboBoxItem>
        <ComboBoxItem>X-Large</ComboBoxItem>
    </ComboBox>
</Grid>

虽然可以直接在 XAML 标记中对这些控件中显示的项进行编码，但更有可能的是使用数据绑定来显示它们的值。您将很快看到数据绑定。

使用 Visual Studio 设计器

尽管使用文本编辑器完全通过代码创建窗口是很有可能的，但是您可能会发现这个过程非常乏味，并且不是非常有效地利用您的时间。幸运的是，Visual Studio IDE 包含了一个优秀的设计器来创建你的 WPF 窗口。使用设计器，您可以将控件从工具箱拖放到 Visual Studio 设计器，使用 Visual Studio 属性窗口设置其属性，并在使用 XAML 编辑器输入代码时获得自动完成和语法检查的好处。图 11-4 显示了 Visual Studio 设计器中的一个窗口。

图 11-4 。在 Visual Studio 中设计窗口

处理控制事件

Windows 图形用户界面(GUI)程序是事件驱动的。事件是由用户或系统发起的动作，例如，每当用户点击一个按钮，或者一个SqlConnection对象发出一个StateChange事件。事件驱动的应用通过执行您指定的代码来响应发生的各种事件。为了响应事件，您定义了在特定事件发生时要执行的事件处理程序。正如你在第八章中看到的 .NET Framework 使用委托来绑定事件，并编写事件处理程序来响应事件。一个委托对象维护一个方法调用列表，这些方法已经订阅了在事件发生时接收通知。当事件发生时(例如，单击按钮)，控件将通过调用事件的委托来引发事件，该事件的委托又将调用已订阅接收事件通知的事件处理程序方法。虽然这听起来很复杂，但是框架类为您完成了大部分工作。

在 Visual Studio 中，可以通过编写 XAML 代码或在控件的“属性”窗口中选择事件来将事件添加到 WPF 控件中。图 11-5 显示了在 XAML 编辑器窗口中连接一个事件处理器；图 11-6 显示了使用属性窗口的事件选项卡连接事件处理程序。注意，当在代码中使用控件时，您需要使用Name属性给它们一个唯一的名称。

图 11-5 。在 XAML 编辑器中连接事件处理程序

图 11-6 。在“属性”窗口中连接事件处理程序

下面的代码显示了按钮单击事件的代码隐藏文件中插入的事件处理程序方法:

private void btnSubmit_Click(object sender, RoutedEventArgs e)
{
}

按照惯例，事件处理程序方法的名称以发出事件的对象的名称开头，后面跟着一个下划线(_)和事件的名称。然而，事件处理程序的实际名称并不重要。XAML 代码中的Click属性将这个方法添加到事件委托对象的调用列表中。

所有事件处理程序都必须提供两个参数，这两个参数在触发事件时传递给方法。第一个参数是 sender，它表示启动事件的对象。类型为System.Windows.RoutedEventArgs的第二个参数是一个对象，用于传递特定事件的任何特定信息。

因为 .NET Framework 使用委托进行事件通知，如果事件具有相同的签名，您可以使用相同的方法处理多个事件。例如，您可以用同一事件处理程序处理按钮单击事件和菜单单击事件，但不能处理文本框按键事件，因为它具有不同的签名。下面的代码演示如何处理使用相同处理程序方法的两个按钮的按钮单击事件。sender参数被转换为Button类型，并被询问以确定哪个按钮触发了事件。

private void Button_Click(object sender, RoutedEventArgs e)
{
    Button btn = (Button)sender;
    if (btn.Name == "btnCancel")
    {
        //Cancel code goes here
    }
    else if (btn.Name == "btnSubmit")
    {
        //Submit code goes here
    }
}

在下面的活动中，您将使用表单和控件构建一个简单的备忘录查看器应用，该应用允许用户加载和查看备忘录文档。

活动 11-1。使用窗口和控件

在本活动中，您将熟悉以下内容:

• 创建基于 Windows 窗体的 GUI 应用
• 使用菜单、状态条和对话框控件
• 使用控制事件

创建备忘录查看器界面

要创建备忘录查看器界面，请遵循以下步骤:

1. 启动 Visual Studio。选择文件新建项目。

2. 选择 C# 项目文件夹下的 WPF 应用。将项目重命名为 Activity11_1，然后单击“OK”按钮。

3. 该项目包含一个 MainWindow.xaml 文件。这个文件是你设计用户界面的地方。该项目还包含一个 MainWindow.xaml.cs 文件。这是代码隐藏文件，您将在其中添加代码来响应事件。如果尚未打开，请在 xaml 编辑器窗口中打开 MainWindow.xaml 文件。

4. In the Window tag of the XAMLmarkup, add a Name attribute with a value of “MemoViewer”. Change the Title attribute to “Memo Viewer”.

   <Window x:Name="Memoviewer" x:Class="Act11_1.MainWindow"

   xmlns="``http://schemas.microsoft.com/winfx/2006/xaml/presentation

   xmlns:x="``http://schemas.microsoft.com/winfx/2006/xaml

   Title="Memo Viewer" Height="350" Width="525">

5. Add a DockPanel control in the Grid control.

   <Grid>

   <DockPanel LastChildFill="True">

   </DockPanel>

   </Grid>

6. Add a Menu control inside the DockPanel and dock it to the top using the following XAML:

   <DockPanel LastChildFill="True">

   <Menu DockPanel.Dock="Top">

   <MenuItem Header="_File">

   <MenuItem Name="mnuNew" Header="_New. . ." />

   <Separator />

   <MenuItem Name="mnuOpen"  Header="_Open. . ." />

   <Separator />

   <MenuItem Name="mnuSave" Header="_Save" />

   <MenuItem Name="mnuSaveAs" Header="_Save As. . ." />

   <Separator />

   <MenuItem  Name="mnuExit" Header="_Exit" />

   </MenuItem>

   <MenuItem Header="_Edit">

   <MenuItem Header="_Cut. . ." />

   <MenuItem Header="_Copy. . ." />

   <MenuItem Header="_Paste" />

   </MenuItem>

   </Menu>

   </DockPanel>

7. Add a StatusBar control by inserting the following code between the ending Menu tag and the ending DockPanel tag. Note that you are using a Grid control inside the StatusBar control to lay out the items in the StatusBar.

   <StatusBar DockPanel.Dock="Bottom">

   <Grid>

   <Grid.RowDefinitions>

   <RowDefinition Height="*"/>

   </Grid.RowDefinitions>

   <Grid.ColumnDefinitions>

   <ColumnDefinition Width="4*"/>

   <ColumnDefinition Width="*"/>

   </Grid.ColumnDefinitions>

   </Grid>

   <StatusBarItem Grid.Column="0" HorizontalAlignment="Left">

   <TextBlock Name="sbTextbox1">File Name</TextBlock>

   </StatusBarItem>

   <StatusBarItem Grid.Column="1" HorizontalAlignment="Right">

   <TextBlock Name="sbTextbox2">Date</TextBlock>

   </StatusBarItem>

   </StatusBar>

8. Add a RichTextBox control after the StatusBar end tag and before the DockPanel end tag.

   </StatusBar>

   <RichTextBox Name="rtbMemo" />

   </DockPanel>

9. Note that as you add the XAML, the Visual Designer updates the appearance of the window. The Memo Viewer window should look similar to the one shown Figure 11-7.

   

   图 11-7 。完整的 MemoEditor 窗口

10. 构建解决方案。如果有任何错误，请修复并重新构建。

编码控制事件

要对控制事件进行编码，请遵循以下步骤:

1. In the XAML Editor window, add the Loaded event attribute to the Window, as shown:

   <Window x:Class="Act11_1.MainWindow"

   xmlns="``http://schemas.microsoft.com/winfx/2006/xaml/presentation

   xmlns:x="``http://schemas.microsoft.com/winfx/2006/xaml

   Name="MemoViewer" Title="Memo Viewer" Height="350" Width="525"

   Loaded="MemoViewer_Loaded">

2. Open the codebehind file by right-clicking the XAML code editor and selecting View Code. Add the following code to the MemoViewer_Loaded event handler. When the window loads, it should show the message on the left side of the StatusPanel and the date on the right.

   private void MemoViewer_Loaded(object sender, RoutedEventArgs e)

   {

   sbTextbox1.Text = "Ready to load file";

   sbTextbox2.Text = DateTime.Today.ToShortDateString();

   }

3. In the XAML editor, add the Click event to the mnuOpen control.

   <MenuItem Name="mnuOpen"  Header="_Open. . ."

   Click="mnuOpen_Click"/>

4. In the Code Editor window of the codebehind file, add the following code to the menu click event. This code configures and launches an Open File Dialog box, which returns the file path. The file path is then passed to a FileStream object, which loads the file into the RichTextBox. The file path is also loaded into the StatusBar TextBox.

   private void mnuOpen_Click(object sender, RoutedEventArgs e)

   {

   // Configure open file dialog box

   Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();

   dlg.FileName = "Document"; // Default file name

   dlg.DefaultExt = ".txt"; // Default file extension

   dlg.Filter = "Text documents (.txt)|*.txt"; // Filter files by extension

   // Show open file dialog box

   Nullable<bool> result = dlg.ShowDialog();

   // Process open file dialog box results

   if (result == true)

   {

   // Open document and load RichTextBox

   string fileName = dlg.FileName;

   TextRange range;

   System.IO.FileStream fStream;

   if (System.IO.File.Exists(fileName))

   {

   range = new TextRange(rtbMemo.Document.ContentStart,

   rtbMemo.Document.ContentEnd);

   fStream = new System.IO.FileStream

   (fileName,System.IO.FileMode.OpenOrCreate);

   range.Load(fStream, System.Windows.DataFormats.Text );

   fStream.Close();

   }

   sbTextbox1.Text = fileName;

   }

   }

5. Add a click event for the mnuExit control with the following code to close the window:

   private void mnuExit_Click(object sender, RoutedEventArgs e)

   {

   this.Close();

   }

6. 生成解决方案并修复任何错误。

7. 在 c 盘上创建一个备忘录文件夹。使用记事本，创建一个包含测试消息的文本文件。将文件另存为 Test.txt。

8. 选择调试开始。通过加载 Test.txt 文件来测试应用。查看文件后，单击退出菜单关闭窗口。

9. 测试完应用后，退出 Visual Studio。

创建和使用对话框

对话框 是基于 windows 的 GUI 应用中常用的特殊窗口，用于显示或检索用户的信息。普通窗口和对话框的区别在于对话框是有模式显示的。在对话框关闭之前，模式窗口阻止用户在应用中执行其他任务。在 Visual Studio 中启动一个新项目时，会出现一个新项目对话框，如图图 11-8 所示。您还可以使用对话框向用户提供关键信息，并询问他们是否做出响应。例如，如果你试图在调试模式下运行一个应用，并且遇到一个编译错误，Visual Studio IDE 会显示一个对话框询问你是否要继续(参见图 11-9 )。

图 11-8 。“新建项目”对话框

图 11-9 。使用对话框显示关键信息

向用户显示一个消息框

图 11-9 所示的对话框是一种特殊的预定义类型，称为消息框。MessageBox类是System.Windows名称空间的一部分。这个MessageBox类可以显示一个标准的 Windows 消息对话框。为了向用户显示一个 MessageBox，您调用 MessageBox 的静态Show方法，就像这样:

MessageBox.Show("File Saved");

Show方法被重载，以便您可以选择显示 MessageBox 图标、显示标题、更改显示的按钮以及设置默认按钮。唯一需要的设置是要在表单上显示的文本消息。图 11-10 显示了前面代码显示的消息框。

图 11-10 。一个基本的消息框

下面的代码使用一些其他参数调用Show方法。图 11-11 显示了显示的结果消息框。有关各种可用参数和设置的更多信息，请在 Visual Studio 帮助文件中查找MessageBox类。

MessageBox.Show("Are you sure you want to quit?",
           "Closing Application",MessageBoxButton.OKCancel,
           MessageBoxImage.Question);

图 11-11 。更复杂的消息框

您将经常使用 MessageBox 来查询用户对某个问题的响应。用户通过点击按钮来响应。结果以MessageBoxResult枚举的形式作为MessageBox.Show方法的返回值传递回来。以下代码捕获用户输入的对话框结果，并根据结果关闭(或不关闭)窗口:

MessageBoxResult result =  MessageBox.Show("Are you sure you want to quit?",
                    "Closing Application",MessageBoxButton.OKCancel,
                    MessageBoxImage.Question);
if (result == MessageBoxResult.OK)
{
    this.Close();
}

创建自定义对话框

最激动人心的特性之一 .NET Framework 就是它的扩展性。尽管有许多类型的对话框，你可以使用“开箱即用”的来完成打印、保存文件和加载文件等任务。您还可以构建自己的自定义对话框。创建自定义对话框的第一步是在应用中添加一个新窗口。接下来，添加与用户交互所需的任何控件。图 11-12 显示了一个对话框，你可以用它来验证用户的身份。

图 11-12 。自定义对话框

将 Cancel 按钮的IsCancel属性设置为 true 会将其与 ESC 键的快捷键相关联。将登录按钮的IsDefault属性设置为 true 会将其与键盘回车键相关联。这显示在下面的 XAML 代码中:

<StackPanel Grid.Column="1"  Grid.Row="3" Orientation="Horizontal">
    <Button Name="loginButton" IsDefault="True">Login</Button>
    <Button Name="cancelButton" IsCancel="True">Cancel</Button>
</StackPanel>

当单击登录按钮时，按钮的 click 事件负责验证用户输入并将DialogResult属性设置为 true 或 false。这个值被返回给调用 DialogWindow 的Show方法的窗口，以便进一步处理。下面的代码显示了被调用的 LoginDialog 窗口和被询问的DialogResult属性。请注意，调用窗口可以访问 DialogWindow 上定义的对象。在本例中，它正在询问txtName文本框的Text属性。

LoginDialog dlg = new LoginDialog();
dlg.Owner = this;
dlg.ShowDialog();
if (dlg.DialogResult == false)
{
    string user = dlg.txtName.Text;
    MessageBox.Show("Invalid login for " + user, "Warning",
               MessageBoxButton.OK, MessageBoxImage.Exclamation);
               this.Close();
}

基于 Windows 的图形用户界面中的数据绑定

一旦从业务逻辑层检索到数据，就必须将其呈现给用户。用户可能需要通读数据、编辑数据、添加记录或删除记录。您想要添加到窗口中的许多控件都可以显示数据。选择使用哪种控件通常取决于要显示的数据类型、操作数据的方式以及界面的设计。在控件中 .NET 开发人员通常用来显示数据的是文本框、数据网格、标签、列表框、复选框和日历。当数据源的不同字段在单独的控件中呈现给用户时(例如，名文本框和姓文本框)，控件保持同步以显示相同的记录是很重要的。

那个 .NET Framework 通过称为数据绑定的过程封装了将控件同步到数据源的大部分复杂性。当您在控件和某些数据之间创建绑定时，您正在将绑定目标绑定到绑定源。绑定对象处理绑定源和绑定目标之间的交互。单向绑定导致对源属性的更改自动更新目标属性，但对目标属性的更改不会传播回源属性。这对于只读情况很有用。双向绑定导致源属性或目标属性的改变自动更新另一个。这对于完整的数据更新场景非常有用。

使用 DataContext 绑定控件

若要将控件绑定到数据，您需要一个数据源对象。容器控件的 DataContext 允许子控件从其父控件继承有关用于绑定的数据源的信息。下面的代码设置顶层窗口控件的DataContext属性。它使用 DataSet 和 TableAdapter 填充一个Table对象，并将其设置为窗口的 DataContext。

private void Window_Loaded(object sender, RoutedEventArgs e)
{
    pubsDataSet dsPubs = new pubsDataSet();
    pubsDataSetTableAdapters.storesTableAdapter taStores =
        new pubsDataSetTableAdapters.storesTableAdapter();
    taStores.Fill(dsPubs.stores);
    this.DataContext = dsPubs.stores.DefaultView;
}

下面的 XAML 代码使用Path属性将数据网格列绑定到商店表列。使用Binding作为源意味着“查找容器层次结构，直到找到 DataContext。”在这种情况下，它是窗口容器的 DataContext。

<DataGrid  AutoGenerateColumns="False"  ItemsSource="{Binding}">
    <DataGrid.Columns>
        <DataGridTextColumn x:Name="stor_idColumn"
             Binding="{Binding Path=stor_id}" Header="Id"  />
        <DataGridTextColumn x:Name="stor_nameColumn"
             Binding="{Binding Path=stor_name}" Header="Name" />
        <DataGridTextColumn x:Name="stateColumn"
            Binding="{Binding Path=state}" Header="State" />
        <DataGridTextColumn x:Name="zipColumn"
               Binding="{Binding Path=zip}" Header="Zip" />
    </DataGrid.Columns>
</DataGrid>

加载了商店数据的结果数据网格如图 11-13 所示。

图 11-13 。用数据网格显示商店数据

在以下活动中，您将把 DataGrid 控件绑定到包含 Pubs 数据库中的数据的 DataTable。您还将使用 DataAdapter 将 DataGrid 控件中所做的数据更改更新回 Pubs 数据库。

活动 11-2。使用数据绑定控件

在本活动中，您将熟悉以下内容:

• 将数据网格绑定到数据表
• 使用 DataAdapter 更新数据

将数据网格绑定到数据表

要将 DataGrid 绑定到 DataTable 对象，请执行以下步骤:

创建数据集

1. 启动 Visual Studio。选择文件新建项目。
2. 选择 WPF 应用。将项目重命名为 Activity11_2，然后单击“确定”按钮。
3. 项目加载后，找到位于屏幕左侧的“数据源”窗口。单击添加新数据源链接。
4. 在数据源配置向导中，选择数据库的数据源类型，然后单击下一步继续。
5. 在“选择数据库模型”窗口中，选择数据集，然后单击“下一步”。
6. 在“选择您的数据连接”窗口中，选择或创建到 Pubs 数据库的连接，然后单击“下一步”。
7. 在下一个屏幕上，保存到应用配置文件的连接。
8. 在“选择您的数据库对象”窗口中，展开表的节点并选择 authors 表。单击完成按钮。
9. 注意在“解决方案资源管理器”窗口中，pubsDataSet.xsd 文件已添加到该文件中。该文件表示基于 pubs 数据库的强类型 dataset 对象。在解决方案资源管理器中双击文件节点以启动数据集可视化编辑器。
10. The visual editor contains an authors table. Select the authorsTableAdapter, as shown in Figure 11-14. In the Properties window, notice that the select, insert, update, and delete commands have been generated for you (see Figure 11-15).

![9781430249351_Fig11-14.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig11-14.jpg)

图 11-14 。选择 authorsTableAdapter

![9781430249351_Fig11-15.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig11-15.jpg)

图 11-15 。查看生成的命令文本

创建窗口布局

1. 在 XAML 编辑器窗口中打开主窗口。将窗口标题更改为“电话列表”。

2. Inside the Grid tags, add a DockPanel control. Inside the DockPanel, add a StackPanel.

   <Grid>

   <DockPanel>

   <StackPanel DockPanel.Dock="Top" Orientation="Horizontal">

   </StackPanel>

   </DockPanel>

   </Grid>

3. Inside the StackPanel, add two buttons—one for getting data and one for updating data. Add a Click event handler for each button.

   <StackPanel DockPanel.Dock="Top" Orientation="Horizontal">

   <Button Name="btnGetData" Content="Get Data"

   Click="btnGetData_Click" />

   <Button Name="btnSaveData" Content="Save Data" />

   </StackPanel>

4. Outside the StackPanel but inside the DockPanel, add a DataGrid.

   <DataGrid Name="dgAuthors" AutoGenerateColumns="True"

   DockPanel.Dock="Bottom" />

   </DockPanel>

   </Grid>

加载数据网格

1. 在代码编辑器窗口中打开 MainWindow.xaml.cs 文件。

2. Add three class level variables of type pubsDataset, authorsTableAdapter, and authorsDataTable.

   public partial class MainWindow : Window

   {

   pubsDataSet _dsPubs;

   pubsDataSetTableAdapters.authorsTableAdapter _taAuthors;

   pubsDataSet.authorsDataTable _dtAuthors;

3. In the btnGetData_Click event, add code to fill the _taAuthors table and set it equal to the DataContext of the dgAuthors grid.

   private void btnGetData_Click(object sender, RoutedEventArgs e)

   {

   _dsPubs = new pubsDataSet();

   _taAuthors = new pubsDataSetTableAdapters.authorsTableAdapter();

   _dtAuthors = new pubsDataSet.authorsDataTable();

   _taAuthors.Fill(_dtAuthors);

   this.dgAuthors.DataContext = _dtAuthors;

   }

4. Switch back to the XAML Editor Window and add the ItemsSource binding to the DataGrid’s XAML code. This will bind it to the DataContext.

   <DataGrid Name="dgAuthors" AutoGenerateColumns="True"

   DockPanel.Dock="Bottom" ItemsSource="{Binding}" />

5. 选择调试开始。单击“获取数据”按钮测试应用。数据网格将加载作者的数据(见图 11-16 )。请注意，由于 DataGrid 的AutoGenerateColumns属性被设置为 true，因此网格将加载表中的所有列。网格列的标题也与作者的表格列同名。

6. After viewing the window, stop the debugger.

   

   图 11-16 。作者数据网格

更新数据

1. Open the MainWindow.xaml.cs file in the Code Editor window. Add the following code to update the data in the btnSaveData_Click event handler. This code uses the table adapter’s update command to send the changes back to the database. You must also alter the btnSaveData’s XAML to call this event when it is clicked.

   private void btnSaveData_Click(object sender, RoutedEventArgs e)

   {

   try

   {

   _taAuthors.Update(_dtAuthors);

   MessageBox.Show("Data Saved.",

   "Information", MessageBoxButton.OK,

   MessageBoxImage.Information);

   }

   catch (Exception ex)

   {

   MessageBox.Show("Could not save data!",

   "Warning",MessageBoxButton.OK,

   MessageBoxImage.Warning);

   }

   }

2. Update the Grid’s XAML code to only show the first name, last name, and phone columns.

   <DataGrid Name="dgAuthors" AutoGenerateColumns="False"

   DockPanel.Dock="Bottom" ItemsSource="{Binding}">

   <DataGrid.Columns>

   <DataGridTextColumn Header="Last Name"

   Binding="{Binding Path='au_lname'}" />

   <DataGridTextColumn Header="First Name"

   Binding="{Binding Path='au_fname'}" />

   <DataGridTextColumn Header="Phone"

   Binding="{Binding Path='phone'}" />

   </DataGrid.Columns>

   </DataGrid>

3. 选择调试开始。单击“获取数据”按钮测试应用。更新一些名字。单击“保存数据”按钮，然后单击“获取数据”按钮，验证名称是否已保存到数据库中。

4. 测试后，停止调试器并退出 Visual Studio。

创建和使用控件和数据模板

在 WPF 中，每个控件都有一个管理其视觉外观的模板。如果你没有显式地设置它的Style属性，那么它使用一个默认的模板。创建一个定制模板并将其分配给Style属性是改变应用外观的一个很好的方法。图 11-17 显示了一个使用控件模板创建的圆形按钮。

图 11-17 。使用自定义模板创建圆形按钮

以下 XAML 是定义自定义模板的标记，该模板用于创建图 11-17 中的圆形按钮。

<Window.Resources>
      <Style x:Key="RoundedButtonStyle" TargetType="Button">
          <Setter Property="Template">
              <Setter.Value>
                  <ControlTemplate TargetType="{x:Type Button}">
                      <Grid>
                          <Ellipse Fill="{TemplateBinding Background}"
                           Stroke="{TemplateBinding BorderBrush}"/>
                          <ContentPresenter HorizontalAlignment="Center"
                                        VerticalAlignment="Center"/>
                      </Grid>
                  </ControlTemplate>
              </Setter.Value>
          </Setter>
      </Style>
</Window.Resources>

以下 XAML 代码用于使用按钮的Style属性将自定义样式绑定到按钮:

<Button Content="Rounded Button" Style="{StaticResource RoundedButtonStyle}"

除了控件样式模板，您还可以创建数据模板。当您在 UI 中绑定业务对象时，数据模板允许您自定义业务对象的外观。需要使用自定义数据模板的一个很好的例子是列表框。默认情况下，它将数据呈现为单行文本。当您试图将它绑定到 employee 对象列表时，它会调用ToString()方法并将其写出到显示器上。正如你在图 11-18 中看到的，这显然不是你想要的。

图 11-18 。使用默认数据模板的列表框

通过向 ListBox 控件添加 DataTemplate，不仅可以显示雇员数据，还可以控制数据的显示方式。下面的 XAML 向列表框添加了一个数据模板，图 11-19 显示了结果:

<ListBox ItemsSource="{Binding}" >
    <ListBox.ItemTemplate>
        <DataTemplate>
            <StackPanel Orientation="Horizontal">
                <TextBlock FontWeight="Bold" Text="{Binding Path='lname'}" />
                <TextBlock Text=", " />
                <TextBlock Text="{Binding Path='fname'}" />
                <TextBlock Text=" " />
                <TextBlock Text="{Binding Path = 'minit'}" />
             </StackPanel>
         </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

图 11-19 。使用自定义数据模板的列表框

在以下活动中，您将使用实体数据模型将 ListBox 控件绑定到从 Pubs 数据库创建的实体。您还将通过同步 ListBox 控件和 DataGrid 控件来创建主从视图。

活动 11-3。使用数据模板

在本活动中，您将熟悉以下内容:

• 将列表框绑定到实体
• 创建数据模板
• 创建主详细视图

将列表框绑定到实体

要将一个列表框绑定到一个实体对象，请遵循以下步骤:

1. 启动 Visual Studio。选择文件新建项目。
2. 选择 Windows 模板下的 WPF 应用。将项目重命名为 Activity11_3，然后单击“确定”按钮。
3. 项目加载后，定位“数据源”窗口(它应该在设计器窗口的左侧)。单击添加新数据源链接。
4. 在数据源配置向导中，选择数据库的数据源类型。
5. 在“选择数据库模型”窗口中，选择实体数据模型。
6. 在“选择模型内容”窗口中，选择“从数据库生成”选项。
7. 在“选择您的数据连接”窗口中，选择或创建到 Pubs 数据库的连接。将连接保存到应用配置文件。
8. 在“选择数据库对象”窗口中，展开“表”节点，然后选择“商店”和“销售”表。单击完成按钮。
9. 请注意，在“解决方案资源管理器”窗口中，Model1.edmx 文件已添加到项目中。这个文件包含 pubs 数据库中实体和表之间的关系映射。

创建数据模板

1. Add a DockPanel and a ListBox control in the XAML Editor window between the default Grid tags.

   <Grid>

   <DockPanel>

   <ListBox Name="StoresList" DockPanel.Dock="Left" ItemsSource="{Binding}">

   </ListBox>

   </DockPanel>

   </Grid>

2. Add a window Loaded event attribute to the Window’s opening tag.

   <Window x:Class="Activity11_3.MainWindow"

   xmlns="``http://schemas.microsoft.com/winfx/2006/xaml/presentation

   xmlns:x="``http://schemas.microsoft.com/winfx/2006/xaml

   Title="MainWindow" Height="350" Width="525"

   Loaded="Window_Loaded_1">

3. Add a Window_Loaded event handler in the code file that sets the DataContext of the ListBox to the stores entities.

   private void Window_Loaded_1(object sender, RoutedEventArgs e)

   {

   pubsEntities pEntities = new pubsEntities();

   this.StoresGrid.DataContext = pEntities.stores.ToList<store>();

   }

4. Add a DataTemplate to display the store name in a TextBlock control inside the ListBox control.

   <ListBox Name="StoresList" DockPanel.Dock="Left"

   ItemsSource="{Binding}">

   <ListBox.ItemTemplate>

   <DataTemplate>

   <TextBlock FontWeight="Bold" Text="{Binding Path='stor_name'}" />

   </DataTemplate>

   </ListBox.ItemTemplate>

   </ListBox>

5. 选择调试开始。确保列表框显示商店名称。查看完列表框后，停止调试器。

6. To implement a master/detail data view, add a DataGrid control to the DockPanel control after the ListBox control. The Binding of the grid is set to the same as the list box, which is the store entity, but the binding path is set to the sales entity. This will cause the data grid to show the sales items of the store selected in the list box.

   <DataGrid Name="SalesGrid" DockPanel.Dock="Right"

   ItemsSource="{Binding Path='sales'}" AutoGenerateColumns="False">

   <DataGrid.Columns>

   <DataGridTextColumn Header="Order Number"

   Binding ="{Binding Path ='ord_num'}"/>

   <DataGridTextColumn Header="Order Date"

   Binding="{Binding Path='ord_date'}"/>

   </DataGrid.Columns>

   </DataGrid>

7. Add the following property to the ListBox control in the XAML code. This will ensure that the ListBox control and DataGrid control will remain in sync.

   IsSynchronizedWithCurrentItem="True"

8. Launch the application in the debugger. Your window should look similar to Figure 11-20. Click on different stores in the list box. You should see the data grid update with the store’s sales data. After testing, stop the debugger and close Visual Studio.

   

   图 11-20 。查看主/详细数据

摘要

在这一章中，你看到了应用接口层的实现。您通过基于 WPF 的应用前端实现了用户界面。在这个过程中，您仔细研究了 .NET Framework 用于实现丰富的基于 Windows 的用户界面。您看到了如何使用 XAML 语法来定义界面的控件和布局。您还看到了将控件绑定到数据并呈现给用户是多么容易。在第十三章中，您将重新审视这些概念，并将它们应用于开发新的 Windows 8 和 Windows Store 应用。

在下一章中，你将再次访问一个. NET 应用的 UI 层，但是不是使用 WPF 实现 GUI，而是将 GUI 实现为一个基于 web 的应用。在这个过程中，您将进一步了解可用于创建基于 web 的 GUI 应用的名称空间，以及实现这些名称空间中包含的类所涉及的技术。`

十二、开发网络应用

在第十一章中，你学习了如何使用 C# 和 WPF 构建一个简单的基于 Windows 的图形用户界面(GUI)。尽管 WPF 让程序员能够轻松地构建极其丰富的用户界面，但假设用户会通过传统的基于 Windows 的 PC 访问你的程序并不总是现实的。随着内部网、web 应用和移动设备的激增，应用现在需要允许用户能够通过各种浏览器和设备访问界面。本章向你展示了如何使用 ASP.NET 构建一个基于网络的用户界面。ASP.NET 是一个 web 框架，支持两种构建 web 应用的方法:Web 表单和 ASP.NET MVC 应用(基于模型-视图-控制器模式)。出于刚开始学习 web 编程的目的，我建议使用 Web 表单。Web 表单提供了你在第十一章中使用过的熟悉的控件和基于事件的编程模型。(关于 Web 表单开发和 MVC 之间区别的讨论，请访问 ASP.NET 官方网站http://www.asp.net/)

在本章中，您将执行以下任务:

• 创建网页
• 使用控件
• 响应页面和控件事件
• 保持状态
• 实现数据绑定控件

网页和网络表单

ASP.NET 网页 为你的网络应用提供用户界面。虽然你可以用传统的 HTML 网页建立一个网站，ASP.NET 网页提供了许多优势。它们支持客户端和服务器端应用逻辑的实现。编程模型基于一个熟悉的面向对象的事件驱动范例。ASP.NET 建在山顶上 .NET Framework 并获得它提供的所有好处，如类型安全、托管代码和健壮的类库。ASP.NET 的网页被设计成可以在许多流行的桌面浏览器上运行，比如 Internet Explorer 和 Chrome。当呈现 ASP.NET 网页时，检测请求该页面的浏览器的类型。然后使用正确的 HTML 动态呈现页面，以利用特定于浏览器的功能，如布局、格式和样式。

一个网页由两部分组成:可视化界面和编程逻辑。可视化界面由一个文本文件组成，该文本文件包含 HTML 标记标签、对包含文件的引用、处理指令和客户端脚本块。该文本文件的默认扩展名为。aspx 并被称为页面。页面中包含一个 Web 表单。Web 窗体充当将在浏览器中显示的文本和控件的容器。图 12-1 显示了。包含 Web 窗体的 ASP.NET 页的 aspx 文件，该 Web 窗体包含一个 TextBox 控件、一个 Button 控件和一个 Label 控件。当网页被编译时，代码被合并到一个新的类文件中。然后这个文件被编译成一个继承自System.Web.UI.Page类的新类。时执行的就是这个类代码。已请求 aspx 页面。图 12-2 显示了在浏览器(Internet Explorer)中呈现的页面。

图 12-1 。中包含的代码。aspx 文件

图 12-2 。在 IE 中呈现的网页

查看页面顶部的 page 指令可以发现编程模型的第二部分，它被称为代码隐藏文件，由. aspx.cs 扩展名表示。代码隐藏文件包含一个分部类文件。代码放在分部类文件中，以处理由页面或页面中包含的控件公开的任何必要事件。下面的类代码包含在链接到。图 12-1 : 中的 aspx 文件

public partial class Page1 : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {

    }
}

当浏览器请求网页时，页面文件和代码隐藏文件结合在一起，并为。aspx 文件，并编译成一个可执行的页面类文件。正是这个页面类拦截和处理传入的请求。处理完传入的请求后，Page 类动态地创建一个 HTML 响应流并将其发送回浏览器。因为 Page 类是编译代码，所以执行速度比依赖解释脚本的技术快得多。Internet 信息服务(IIS) Web 服务器还能够在内存中缓存执行代码，以进一步提高性能。

Web 服务器控件基础

那个 .NET Framework 提供了一组专门用于在 Web 窗体中承载的 Web 服务器控件。可用的 Web 服务器控件类型包括常见的窗体控件，如 TextBox、Label 和 Button，以及更复杂的控件，如 GridView 和 Calendar。Web 服务器控件从开发人员那里抽象出 HTML 编码。当 Page 类向浏览器发送响应流时，Web 服务器控件使用适当的 HTML 呈现在页面上。发送到浏览器的 HTML 取决于浏览器类型和已进行的控制设置等因素。

下面的代码用于在 Web 窗体中放置一个 TextBox Web 服务器控件:

<asp:TextBox ID="txtName" runat="server" BorderStyle="Dashed"
    ForeColor="#0000C0"></asp:TextBox>

然后，该控件在 Internet Explorer (IE) 10.0 中呈现为以下 HTML 代码:

<input name="txtName" type="text" id="txtName"
style="color:#0000C0;border-style:Dashed;" />

如果 TextBox 控件的TextMode属性被设置为MultiLine，网页中的代码将被修改以反映该属性设置:

<asp:TextBox ID="txtName" runat="server" BorderStyle="Dashed" ForeColor="#0000C0"
 TextMode="MultiLine"></asp:TextBox>

尽管 Web 服务器控件的代码变化很小，但呈现给浏览器的 HTML 代码却变成了一个完全不同的 HTML 控件:

<textarea name="txtName" rows="2" cols="20" id="txtName"
style="color:#0000C0;border-style:Dashed;"></textarea>

Web 服务器控件提供 .NET 程序员的许多优势，包括熟悉的事件驱动对象模型、带有动态呈现的自动浏览器检测、数据绑定功能和自动控件状态维护，等等。

了解网页和 Web 服务器控件继承的层次结构

包含在网页界面代码的顶部。aspx 文件是下面的页面指令:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Page2.aspx.cs" Inherits="Chapter12Demo1.Page2" %>

这段代码揭示了网页接口代码继承自 Page2.aspx.cs 文件中的Page2代码隐藏类。代码隐藏类又继承了系统中的Page类。Web.UI 命名空间:

public partial class Page2 : System.Web.UI.Page

Page类公开了编写 Web 应用和与 Web 服务器交互所需的重要功能。例如，它支持对应用、会话、响应、请求和服务器对象的访问。Application 对象允许 Web 应用的所有用户共享值。Request 对象允许在 Web 请求期间读取网页发送的值。Page类还公开了一些功能，如处理由嵌入在网页中的脚本发起的回发事件、发起页面级验证以及注册服务器控件所需的隐藏字段。

如果您进一步追踪 Web 页面的继承链，您会发现Page类继承了TemplateControl类的功能。此类添加了对加载用户控件的支持，用户控件是通常为在多个网页中划分和重用用户界面(UI)功能而创建的自定义控件。用户控件是在中创建的。ascx 文件并由网页托管。除了管理插入到网页中的用户控件，TemplateControl类还向Page类添加了事务支持和错误处理功能。

TemplateControl类继承自Control类。Control类公开了所有服务器控件所需的大部分功能。这个类包括重要的属性，比如ID和Page属性。属性获取并设置控件的编程标识符，属性获取包含控件的页面对象的引用。Control类公开了呈现控件和任何子控件的 HTML 代码的方法。有处理和引发事件的方法，如Load、Unload和PreRender事件。Control类还公开了向 Web 服务器控件添加数据绑定支持所需的功能。图 12-3 显示了Page类在类视图窗口中的层次链。

图 12-3 。页面类的层次链

追踪 Web 服务器控件的层次链——例如，TextBox 控件——发现它们也从Control类获得了很多功能。当您将 TextBox 服务器控件放在 Web 表单上时，它会在运行时实例化一个属于System.Web.UI.WebControls命名空间的TextBox类的对象实例。该类公开文本框所需的属性、方法和事件。例如，它将这些属性定义为Text、ReadOnly和Wrap属性。TextBox类还增加了引发和处理TextChanged事件的功能。

所有 Web 服务器控件类都继承了WebControl类的通用功能。WebControl类提供了控制控件在浏览器中呈现时的外观的属性。例如，ForeColor、Backcolor、Height和Width属性是在WebControl类中定义的。它还定义了控制控件行为的属性，如Enabled和TabIndex属性。WebControl类继承了前面讨论过的Control类。图 12-4 在类图中显示了一个文本框 Web 服务器控件的层次链。

图 12-4 。文本框控件的层次结构链

使用 Visual Studio 网页设计器

Visual Studio 集成开发环境(IDE)包括一个优秀的网页设计器。使用设计器，您可以将控件从工具箱拖放到网页上，并使用“属性”窗口设置控件属性。图 12-5 显示了 Visual Studio 设计器工具箱中的一些可用控件。

图 12-5 。Visual Studio 网页设计器工具箱

网页设计器在窗口底部包含三个选项卡——设计、拆分和源代码。这些选项卡将窗口中的视图从网页的可视表示(设计)切换到 ASP.NET 和 HTML 标记(源)。拆分视图将设计器和源代码显示为一个拆分窗口。“源”视图显示用于呈现页面的标记代码，并允许您将客户端脚本插入到页面中。图 12-6 显示了在设计器的分割视图中显示的网页。

图 12-6 。拆分视图中的 Visual Studio 网页设计器

网页生命周期

当一个网页被请求时，它会经历一系列的阶段，每个阶段都有明确的目的。例如，在初始化阶段，任何主题都被应用到页面上，并且页面上的任何控件都设置了它们的UniqueID属性。在加载阶段，如果页面正在回发(已经呈现过一次，并且正在回发信息)，则控件属性将从存储在隐藏控件(称为视图状态和控件状态)中的信息中加载(视图状态将在本章的后面进行更详细的描述)。回发事件处理阶段是调用控件事件处理程序的地方。为了正确调试网页，了解页面生命周期的各个阶段以及它们发生的时间是很重要的。表 12-1 总结了请求页面时发生的各个阶段。

表 12-1。页面请求的阶段

阶段	描述
页面请求	ASP.NET 确定页面是否需要被解析和编译，或者是否可以发送页面的缓存版本。
开始	设置请求和响应等页面属性。页面设置了IsPostBack属性。
初始化	页面上的控件可用，并且设置了每个控件的UniqueID属性。如果适用，母版页和主题也将应用于页面。
负荷	如果请求是回发，则控件属性将加载从视图状态和控件状态恢复的信息。
回发事件处理	如果请求是回发，则调用控件事件处理程序。之后，调用所有验证器控件的 Validate 方法，该方法设置单个验证器控件和页面的IsValid属性。
翻译	在呈现之前，保存页面和所有控件的视图状态。在呈现阶段，页面为每个控件调用Render方法。
倾销	响应和请求等页面对象被卸载，并执行清理。

当页面在其生命周期中运行时，它会引发各种事件，您可以通过创建运行代码的事件处理程序来响应这些事件。web 页面支持自动事件连接，因此当事件发生时，它会寻找具有标准命名的方法来运行。这些方法是以Page_event的形式出现的，所以要为页面加载事件连接一个事件处理程序，您应该将方法命名为Page_Load。在页面中的控件被初始化后，在页面请求开始时发生Page_Load事件。此事件通常用于从服务器控件读取数据和将数据加载到服务器控件中。查询IsPostBack页面属性以确定页面是第一次被查看还是对回发事件的响应。如果是回发，下面的代码使用 page load 事件在页面上写一条消息。

protected void Page_Load(object sender, EventArgs e)
{
    if (IsPostBack)
    {
        Response.Write("This is a post back.");
    }
}

您可以为其他一些常见的页面事件创建事件处理程序，如Page_Init、Page_PreRender和Page_Unload事件。

控制事件

就像 Windows 的图形用户界面(GUI)一样，Web 控件基于事件驱动的模型与用户交互。当客户端发生事件(例如，单击按钮)时，事件信息会在客户端捕获，并通过超文本传输协议(HTTP) post 传输到服务器。在服务器上，事件信息被事件委托对象截获，事件委托对象又通知订阅了调用列表的任何事件处理程序方法。虽然这听起来很复杂 .NET Framework 类抽象并封装了您的大部分流程。

因为通过回发处理事件的开销需要从浏览器到服务器的往返，所以 Web 窗体和服务器控件只公开有限的一组事件。服务器端事件处理程序不支持经常发生的事件，如鼠标移动和按键事件。这些事件通过用脚本编写的客户端事件处理程序来支持。使用服务器端事件处理程序可以响应的一个常见事件是按钮单击事件。

protected void Button1_Click(object sender, EventArgs e)
{
    Response.Write ("Hello " + this.TextBox1.Text);
}

为了将事件绑定到按钮控件，onClick属性被添加到按钮的标记代码中。连接起来响应事件的控件也必须有一个对表单容器集唯一的 ID。

<asp:Button ID="Button1" runat="server" Text="OK" OnClick="Button1_Click"/>

按照约定，控件的事件处理程序方法的名称是发出事件的对象的名称，后跟一个下划线字符和事件的名称(类似于页级事件处理)。然而，事件处理程序的实际名称并不重要。

所有事件处理程序都必须提供两个参数，这两个参数将在事件触发时传递给方法。第一个参数是发送方，它表示启动事件的对象。类型为System.EventArgs的第二个参数e是一个对象，用于传递特定事件的任何特定信息。例如，当单击 DataList 控件中某项的编辑按钮时，就会引发EditCommand事件。事件参数 e 用于传递有关 DataList 控件中正在编辑的项的信息。以下代码检查在DataList中选择的项目是否被启用:

protected void DataList1_EditCommand(object source, DataListCommandEventArgs e)
{
    if (e.Item.Enabled)
    {
        //Add code here.
    }
}

了解应用和会话事件

伴随着页面和控件事件 .NET Framework 提供了拦截和响应在 Web 会话开始或结束时引发的事件的能力。当用户从应用请求页面时，Web 会话开始，当会话被放弃或超时时，Web 会话结束。除了会话事件之外 .NET Framework 公开了几个应用级事件。第一次有人请求 Web 应用中的页面时，就会发生Application_Start事件。Application_BeginRequest在请求任何页面或服务时发生。当结束请求、验证用户、引发错误和停止应用时，会触发相应的事件。会话级和应用级事件处理程序位于 Global.asax.cs 代码隐藏文件中。图 12-7 显示了代码编辑器中的 Global.asax.cs 文件。

图 12-7 。在代码编辑器中打开 Global.asax.cs 文件

当应用开始时，Global.asax 编译成一个动态生成的类，该类从HttpApplication基类派生而来。此类公开并定义 ASP.NET 应用中所有应用对象通用的方法、属性和事件。对HttpApplication类的详细解释超出了本书的范围。有关更多信息，请参见帮助文件中的HttpApplication对象。

注意global . asax 文件是可选的，必须添加到 web 应用中。

活动 12-1。使用网页和服务器控件

在本活动中，您将熟悉以下内容:

• 创建基于 Web 表单的 GUI 应用
• 使用页面和服务器控件事件

创建网络应用

要创建 Web 应用，请按照下列步骤操作:

1. 启动 Visual Studio。在“文件”菜单上，选择“新建网站”。

2. Choose an ASP.NET Empty Web Site. Change the name of the web site at the end of location path Activity12_1. By default, web sites are stored in a folder under the path Documents\Visual Studio 2012\WebSites. Figure 12-8 shows the New Web Site dialog box for creating a Web Site or Service.

   

   图 12-8 。新建网站对话框

3. 在“新建网站”对话框中单击“确定”按钮。

4. 创建网站后，您需要添加一个 Web 表单。在“网站”菜单下，选择“添加新项目”并添加名为 Page1.aspx 的 Web 表单

5. 您将看到源代码视图中的网页设计器。通过单击窗口左下角的选项卡切换到设计视图。

6. Select the <div> tag at the bottom of the Design window (see Figure 12-9).

   

   图 12-9 。选择 div 标签

7. In the Properties window, select the style property and click on the ellipses to launch the Modify Style dialog window. Under the Position category, set the height to 200 pixels (see Figure 12-10) and click the OK button

   

   图 12-10 。设置 div 高度

8. 将页面设计窗口切换到拆分模式。从工具箱中拖动一个 Label 控件，并将其放在源代码窗格中的 div 标记之间。将文本更改为“Hello Stranger…”并将 ID 更改为 lblMessage。

9. You may get a message asking you to synchronize the design view and the source view. After synchronizing the views, your designer should look similar to Figure 12-11.

   

   图 12-11 。添加标签控件

10. In a similar process to step 9, add the controls in Table 12-2 between the div tags. Don’t worry about the positioning on the form yet.

表 12-2。Web 控件属性

| **控制** | **属性** | **值** |
| --- | --- | --- |
| 标签 | `ID` | `lblName` |
|  | `Text` | `Enter your name:` |
| 文本框 | `ID` | `txtName` |
|  | `Text` | `[Blank]` |
| 纽扣 | `ID` | `btnSubmit` |
|  | `Text` | `Submit` |

11. To position a control, select the control in the designer and in the format menu, select Set Position and check Absolute (see Figure 12-12).

![9781430249351_Fig12-12.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig12-12.jpg)

图 12-12 。打开绝对定位

12. Turn on absolute positioning for the rest of the controls. You should now be able to drag them around in the visual designer to position them. Arrange the controls on the form so they look similar to Figure 12-13.

![9781430249351_Fig12-13.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig12-13.jpg)

图 12-13 。定位控件

创建服务器端控件事件处理程序

要创建服务器端控件事件处理程序，请遵循以下步骤:

1. 在设计窗格中，双击提交按钮。此操作将打开 Page1.aspx.cs 代码隐藏页，并为按钮的 click 事件创建一个事件处理程序方法。

2. In the button’s click event handler, check to see if the page request is the result of a postback. If it is, change the lblMessage text to say hello using the text contained in the txtName control:

   protected void btnSubmit_Click(object sender, EventArgs e)
   {
       if (IsPostBack)
       {
           lblMessage.Text = "Hello " + txtName.Text;
       }
   }
   

3. Using the Debug menu, launch the page in debug mode. The first time you launch the debugger for a web project, you will see a dialog box asking if you want to enable debugging in the Web.config file. Click the OK button to enable debugging. When the page displays in the browser, enter your name and click the Submit button. Verify that the page redisplays with your name included in the Hello… message. After testing, close the browser.

   创建非回发服务器控件事件

   要创建非回发服务器控件事件，请执行以下步骤:

4. 使用页面设计器，将 RadioButtonList 控件添加到 Page1。将其位置更改为 absolute，并将其放在 textbox 下方。

5. Change the ID property to rblFontColor. Click the Items collection in the Properties window to display the ListItem Collection Editor dialog box. Add a Black item and a Red item to the list (see Figure 12-14).

   

   图 12-14 。添加列表项

6. In the Properties window for the rblFontColor, click the events button to display the event list (see Figure 12-15).

   

   图 12-15 。选择控制事件

7. 双击SelectedIndexChanged事件。这将带您进入代码隐藏页，并设置处理事件的方法。添加以下代码以更改事件处理程序中 lblMessage 控件的字体颜色:

   protected void rblFontColor_SelectedIndexChanged(object sender, EventArgs e)
   {
       if (rblFontColor.SelectedItem.Value == "Red")
       {
           lblMessage.ForeColor = System.Drawing.Color.Red;
       }
       else
       {
           lblMessage.ForeColor = System.Drawing.Color.Black;
       }
   }
   

8. 使用“调试”菜单，在调试模式下启动页面。当页面显示在浏览器中时，单击红色单选按钮。请注意，事件不会导致回发发生。此事件将一直排队，直到 AutoPostBack 事件触发回发。

9. 在 txtName 控件中输入您的姓名，然后单击 Submit 按钮。处理回发时，会处理rblFontColor的 SelectedIndexChanged 事件和提交按钮的 Click 事件。

10. 测试后，关闭浏览器并退出 Visual Studio。

注意本节只探讨了服务器端事件处理。如果浏览器支持客户端脚本和动态 HTML，您可以将 JavaScript 代码添加到。aspx 页来利用客户端处理功能。

在 Web 应用中存储和共享状态

Web 应用使用无状态协议(HTTP)在浏览器和服务器之间进行通信。然而，在许多 Web 应用中，在用户会话期间需要存在某种状态维护。传统上，有效地维护状态对 Web 程序员来说是一个挑战。为了帮助减轻状态管理的挑战 .NET Framework 提供了几个选项来管理客户端和服务器端的状态。

维护视图状态

Web 应用中需要进行的一种状态管理是在表单回发到客户端时保留控件属性值。因为网页在每次被请求时都会被重新创建和销毁，所以当页面被回发时，客户端对控件所做的任何更改都会丢失。例如，在文本框控件中输入的任何信息在回发时都会丢失。为了克服这种状态丢失，服务器控件有一个ViewState属性，它提供了一个字典对象，用于在回发之间保留控件的值。处理页面时，页面和控件的当前状态被散列到一个字符串中，并保存为页面上的隐藏字段。在回发期间，当初始化控件以将页面呈现回浏览器时，将检索并还原这些值。下面的代码显示了呈现给浏览器的视图状态隐藏控件:

<input type="hidden " name="__VIEWSTATE"
value="dDw1Njg2NjE2ODY7O2w8XN0MTowOz4+upC3lZ6nNLX/ShtpGHJAmi8mpH4=" />

使用查询字符串

虽然视图状态用于存储向同一页面回发之间的信息，但您通常需要将信息从一个页面传递到另一个页面。实现这一点的一种流行方法是使用查询字符串。查询字符串被附加到页面请求 URL 例如，下面的 URL 将一个 ID 字段传递给页面，该页面可用于在数据库中查找值。

http://LocalHost/LookUpAuthorInfo.aspx?AuthorId=30

通过用&符号分隔键值对，可以传递多个查询字符串值。

http://LocalHost/LookUpAuthorInfo.aspx?AuthorId=30&BookTitleId=355

要从查询字符串中检索值，可以使用Request对象的QueryString属性。

int ID = int.Parse(Request.QueryString["AuthorId"]);

注意使用查询字符串的一个缺点是，它们在浏览器中很容易看到，用户可以很容易地更改值。不要使用查询字符串传递敏感数据。

使用 Cookies

您可以使用 cookies 在位于客户端设备上的文本文件中存储少量数据。HttpResponse类的Cookie属性提供了对Cookies集合的访问。Cookies集合包含客户端在Cookies头中传输给服务器的 cookies。该集合包含最初在服务器上生成的 Cookie，并在 Set-Cookie 标头中传输到客户端。因为浏览器只能将 cookie 数据发送到最初创建 cookie 的服务器，并且 cookie 信息在发送到浏览器之前可以被加密，所以这是一种相当安全的维护用户数据的方式。cookies 的一个常见用途是向客户端发送用户身份令牌，下次用户访问网站时可以检索到该令牌。然后使用这个令牌从数据库中检索特定于客户端的信息。使用 cookies 是在访问站点之间维护客户端状态的好方法。在下面的代码中，创建了一个Cookie对象来保存用户访问的日期和时间。这个Cookie对象随后被添加到Cookies集合中，并发送给浏览器:

HttpCookie visitDate = new HttpCookie("visitDate");
DateTime now = DateTime.Now;
visitDate.Value = now.ToString();
visitDate.Expires = now.AddHours(1);
Response.Cookies.Add(visitDate);

要读取 cookie，可以使用Request对象。下面的代码读取 cookies 值并将其加载到 Textbox 控件中。

if (Request.Cookies["visitDate"] != null)
{
    txtLastVisit.Text = Request.Cookies["visitDate"].Value;
}

维护会话和应用状态

Web 应用中经常需要的另一种状态管理是会话状态。会话状态是在用户请求 Web 应用中的各种页面时维护与用户相关的信息的能力。会话状态在服务器上维护，并由HttpSessionState类的对象实例提供。此类提供对 Web 应用的会话状态值和会话级设置的访问。会话状态值存储在只能由当前浏览器会话访问的键值字典结构中。下面的代码检查Session对象，查看当前用户的电话号码是否存储在会话键值对中。Session对象公开了HttpSessionState类的一个对象实例:

if (Session["phone"]==null)
{
    txtphone.Visible = true;
}

默认情况下，会话状态存储在 web 服务器的内存中。有时，您希望会话状态更持久，并在服务器重新启动时保持值不变。在这些情况下，可以将会话值存储在 SQL Server 数据库或 ASP.NET 会话状态服务器中。

尽管会话状态的范围是基于每个会话的，但有时 Web 应用需要在应用中的所有会话之间共享一个状态。您可以使用HttpApplicationState类的对象实例来实现这种全局范围的状态。应用状态存储在类似于会话状态的键-值字典结构中，只是它可用于应用中的所有会话和所有表单。客户机第一次从 Web 应用请求任何 URL 资源时，会创建一个HttpApplicationState类的实例。这个实例通过固有的Application对象公开。以下代码使用Application对象来存储SqlConnection对象的连接字符串属性:

string pubsConnectionString;
pubsConnectionString = "Integrated Security=SSPI;Initial Catalog=pubs;" +
    "Data Source=localhost";
Application["PubsConnectionString"] = pubsConnectionString;

注意应用状态也可以使用System.Web.Caching名称空间中的 cache 类存储在缓存中。

活动 12-2。维护 WEB 应用中的状态

在本活动中，您将熟悉以下内容:

• 如何在 web 窗体中维护视图状态
• 如何使用 cookies 存储和检索数据
• 会话和应用状态之间的区别

维护视图状态

要调查视图状态，请按照下列步骤操作:

1. 启动 Visual Studio。在“文件”菜单上，选择“新建网站”。

2. 选择一个 ASP.NET 空网站。在位置路径练习 12_2 的末尾，更改网站的名称。

3. After the Web Site is created, add a Web Form named Page1.aspx. On the Web form add a Textbox control and a Button control using the following mark up.

   <form id="form1" runat="server">

   <div>

   <asp:TextBox ID="TextBox1" runat="server"></asp:TextBox>

   <asp:Button ID="Button1" runat="server" Text="Button" />

   </div>

   </form>

4. Launch the page using the debugger. After the page loads, right-click on it and chose View source. You should see the mark up for a hidden control used to store the view state.

   <div class="aspNetHidden">

   <input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="s8jATaLWaO0KhQ+roBl8XjQi6d2d0KSSbBx8tZAvxtIM8ih2HwPQotse+N13fzpd3g+w7fbor7Hi2uGUuJ5+H+IomzQJHTf50lldSWwLD3s=" />

   </div>

5. Stop the debugger and add a click event handler to the button.

   <asp:Button ID="Button1" runat="server" Text="Button" OnClick="Button1_Click"/>

6. In the code behind class (Page1.aspx.cs) add the method to handle the button click event. In this event you will save and retrieve a value from the view state that records how many times the button is clicked.

   protected void Button1_Click(object sender, EventArgs e)

   {

   int count;

   if (IsPostBack)

   {

   if (ViewState["count"] != null)

   {

   count = (int)ViewState["count"];

   count += 1;

   ViewState["count"] = count;

   }

   else

   {

   count = 1;

   ViewState.Add("count", count);

   }

   }

   Response.Write(ViewState["count"]);

   }

7. 使用调试器启动页面。点击按钮；您应该会在页面顶部看到一个计数器，每次点击都会增加。测试完成后，停止调试器。

读写 cookie

要使用 cookies 进行调查，请遵循以下步骤:

1. 将第二个 Web 表单添加到名为 Page2 的项目中。

2. On Page1 add a second button and add the following code to the button’s click event handler. This code saves the textbox text to a cookie. It then transfers execution to Page2.

   protected void Button2_Click(object sender, EventArgs e)

   {

   HttpCookie visitor = new HttpCookie("visitor");

   visitor.Expires = DateTime.Now.AddDays(1);

   visitor.Value =TextBox1.Text;

   Response.Cookies.Add(visitor);

   Server.Transfer("Page2.aspx");

   }

3. In Page2’s Page_Load method, retrieve the value of the cookie using the Request object and write it out to the page using the Response object.

   protected void Page_Load(object sender, EventArgs e)

   {

   if (Request.Cookies["visitor"] != null)

   {

   Response.Write("Hello " + Request.Cookies["visitor"].Value);

   }

   }

4. 使用调试器启动第 1 页。在文本框中键入您的姓名，然后单击第二个按钮；您应该看到第 2 页显示了 hello 消息。测试完成后，停止调试器。

会话和应用状态

要调查会话和应用状态，请完成以下步骤:

1. 使用“添加新项”对话框，添加名为 Global.asax 的全局应用类。

2. In the Global.asax code page add the following code to the Session_Start event handler.

   void Session_Start(object sender, EventArgs e)

   {

   Session["SessionStartTime"] = DateTime.Now;

   }

3. 将第三个 Web 表单添加到名为 Page3 的项目中。

4. In the Form_Load event handler for Page3 add the following code to display the session start time.

   protected void Page_Load(object sender, EventArgs e)

   {

   Response.Write(Session["SessionStartTime"]);

   }

5. 在“解决方案资源管理器”窗口中，右击 Page3.aspx 并选择“在浏览器中查看”。您应该会看到显示的会话开始时间。

6. 大约 30 秒后刷新页面。时间不应该改变，因为您在同一个会话中。

7. 启动浏览器的一个新实例，并将第 3 页的网址从第一个浏览器窗口复制到第二个浏览器。您应该看到第 3 页显示了新的时间，因为这是一个新的会话。测试完成后，关闭浏览器。

8. In the Global.asax code page add the following code to the Application_Start event handler.

   void Application_Start(object sender, EventArgs e)

   {

   Application["ApplicationStartTime"] = DateTime.Now;

   }

9. In the Form_Load event handler for Page3 add the following code to display the application start time.

   protected void Page_Load(object sender, EventArgs e)

   {

   Response.Write(Session["SessionStartTime"]);

   Response.Write("<br/>");

   Response.Write(Application["ApplicationStartTime"]);

   }

10. 在“解决方案资源管理器”窗口中，右击 Page3.aspx 并选择“在浏览器中查看”。您应该会看到显示的会话和应用启动时间。

11. 启动浏览器的一个新实例，并将第 3 页的网址从第一个浏览器窗口复制到第二个浏览器。您应该看到第 3 页显示了不同的会话开始时间，但应用开始时间相同，因为这是一个新会话，但应用开始时间相同。测试完成后，关闭浏览器并退出 Visual Studio。

数据绑定 Web 控件

正如传统的基于 Windows 的 GUI 一样，使用基于 Web 的 GUI 开发的程序经常需要与数据进行交互。业务应用的用户需要查看、查询和更新后端数据存储中的数据。幸运的是 .NET Framework 通过公开在 Web 窗体中实现数据绑定控件所需的功能，使这一点变得很容易。

数据绑定控件使在 web 表单中显示数据的过程自动化。ASP.NET 提供了各种控件来显示数据，具体取决于数据的类型、显示方式以及是否可以更新。其中一些控件用于显示只读数据，例如，Repeater 控件显示只读数据的列表。如果需要更新列表中的数据，可以使用 ListView 控件。如果需要以表格格式显示许多列和行的数据，可以使用 GridView 控件。如果需要一次显示一条记录，可以使用 DetailsView 或 FormView 控件。

数据绑定自动化了从数据存储区和数据绑定控件传输数据的过程。为了绑定控件，需要向网页添加一个 DataSource 控件。DataSource 控件不呈现 UI 标记。相反，它们负责提供数据源和数据绑定控件之间的链接。根据数据源的不同，有几种类型的数据源控件可用。表 12-3 列出了提供的数据源类型 .NET 框架。

在下面的标记中，SqlDataSource 控件用于向 Repeater 控件提供数据，Repeater 控件为每个名称重复一个 label 控件。注意数据绑定表达式Eval和Bind的使用。Eval用于单向绑定(只读)Bind用于双向绑定(读取和更新)

表 12-3 。提供的数据源 .NET 框架

数据源	使用
设计器	使您能够绑定到基于实体数据模型的数据。
控件	使您能够使用 Microsoft SQL Server、OleDb、ODBC 或 Oracle 数据库
对象数据源	使您能够使用业务对象或其他类
数据源控件	使您能够使用语言集成查询
数据源控件	使您能够使用 XML 文件。
站点地图	用于 ASP.NET 网站导航。

<asp:SqlDataSource ID="SqlDataSource1" runat="server"
            ConnectionString="<%$ ConnectionStrings:pubsConnectionString %>"
            SelectCommand="SELECT [au_id], [au_lname] FROM [authors]">
</asp:SqlDataSource>

<asp:Repeater ID="Repeater1" runat="server" DataSourceID="SqlDataSource1">
    <ItemTemplate>
        <asp:Label ID="lblName" runat="server" Text='<%# Eval("au_lname") %>'></asp:Label>
        <br />
    </ItemTemplate>
</asp:Repeater>

数据源控件便于快速应用开发。它们允许您在编写最少代码的同时创建支持 CRUD(创建读取更新删除)操作的网页。

模型绑定

虽然 DataSource 控件对于简单的 CRUD 操作和简单的应用来说工作得很好，但是随着应用逻辑和数据访问逻辑变得越来越复杂，使用起来就变得不灵活和麻烦了。它们将数据检索逻辑与表示逻辑混合在一起，这违反了将数据访问逻辑、业务逻辑和表示逻辑分成不同层的 n 层开发原则。为了克服这些限制，ASP.NET 包含了 Web 表单模型绑定。

模型绑定是一种更注重代码的数据访问逻辑，用于数据绑定控件。使用模型绑定，您可以使用ItemType属性声明绑定控件的数据类型。当设置控件的ItemType属性时，Item和BindItem表达式用于将控件绑定到数据源项。Item表达式实现单向绑定(只读)，而BindItem表达式用于双向绑定(读取和更新)。下面的代码显示了如何使用一个 repeater 控件来承载一个 label 控件，并将其Text属性绑定到Employee.Name属性。注意，Repeater 控件的ItemType属性被设置为Employee类。

<asp:Repeater ID="Repeater1" runat="server"
            ItemType="Chapter12Demo1.Employee" SelectMethod="GetEmployee">
    <ItemTemplate>
        <asp:Label ID="Label1" runat="server" Text='<%# Item.Name %>'></asp:Label>
        <br />
    </ItemTemplate>
</asp:Repeater>

要将数据控件配置为使用模型绑定来选择数据，可以将控件的SelectMethod属性设置为页面代码中方法的名称。在上面的例子中，SelectMethod被设置为返回一列Employee对象的GetEmployee方法。数据控件在页面生命周期的适当时间调用该方法，并自动绑定返回的数据。

要实现双向绑定，需要包含一个方法来更新数据，并将其设置为等于控件的UpdateMethod属性。模型绑定会将更新后的值发送到 update 方法，在该方法中，值被更新回数据源。下面的代码定义了一个使用模型绑定来更新雇员的 GridView。注意使用了BindItem和UpdateMethod来实现双向绑定。

<asp:GridView ID="employeesGrid" runat="server" DataKeyNames="ID"
      ItemType="Chapter12Demo1.Employee" AutoGenerateColumns="false" AutoGenerateEditButton="true"
      SelectMethod="GetEmployees" UpdateMethod="UpdateEmployee">
    <Columns>
        <asp:TemplateField>
            <ItemTemplate>
                <asp:Label ID="lblID" runat="server" Text='<%# Item.ID %>'></asp:Label>
            </ItemTemplate>
        </asp:TemplateField>
        <asp:TemplateField>
            <ItemTemplate>
                <asp:Label ID="lblName" runat="server" Text='<%# BindItem.Name %>'></asp:Label>
            </ItemTemplate>
            <EditItemTemplate>
                <asp:TextBox ID="txtName" runat="server" Text='<%# BindItem.Name %>'></asp:TextBox>
            </EditItemTemplate>
        </asp:TemplateField>
    </Columns>
</asp:GridView>

注意针对 ASP.NET 4.5 的新开发，微软推荐使用模型绑定。对于面向以前版本的应用，建议使用数据源控件。

活动 12-3。绑定 GRIDVIEW 控件

在本活动中，您将熟悉以下内容:

• 如何使用 DataSource 控件实现到 Repeater 控件的单向绑定
• 如何使用模型绑定实现 GridView 控件的双向绑定

在 ASP.NET 中继器控件中显示数据

要在 ASP.NET 中继器控件中显示数据，遵循以下步骤:

1. 启动 Visual Studio。在文件菜单上，选择新建网站。

2. 选择一个 ASP.NET 空网站。在位置路径练习 12_3 的末尾，更改网站的名称。

3. 向站点添加一个新的 Web 表单，并将其命名为 AuthorListPage。

4. Open the AuthorListPage in Split view. Drag a SqlDataSource control located under the Data node to the form. You should see a SqlDataSource Tasks pane as in figure 12-16.

   

   图 12-16 。“SqlDataSource”任务窗格

5. 单击配置数据源链接。这将启动一个向导来帮助配置 DataSource 控件。

6. Create a new connection to your SQL Server using the .NET Framework Data Provider for SQL Server (see Figure 12-17).

   

   图 12-17 。选择 SQL Server 数据源

7. 在添加连接对话框中，输入您的服务器名并选择 Pubs 数据库。测试连接，然后单击 OK 按钮。

8. 在下一个屏幕中，选中 yes 将连接字符串保存在配置文件中。

9. In the Configure the Select Statement screen select the au_id and au_lname columns from the authors table as in Figure 12-18.

   

   图 12-18 。配置 Select 语句

10. 在下一个屏幕中，您可以测试查询。测试完查询后，单击 Finish 按钮。

11. In the page source you should see the mark up added to the page to set up the SqlDataSource control.

< ASP:sqldata source ID = " sqldata source 1 " runat = " server "

ConnectionString=" "

SelectCommand="SELECT [au_id]，[au_lname] FROM [authors]" >

12. 在 AuthorListPage 的设计视图中，将 Repeater 控件从工具箱中的数据节点拖到窗体上。将其放在 SqlDataSource 控件之后。
13. 在 Repeater Tasks 弹出窗口中，选择 SQLDataSource1 控件。
14. Switch to the Source window and add the ItemTemplate mark up and the asp:Label mark up inside the Repeater control mark up. Notice the Text property of the label is bound to the au_lname column using the Eval method.

`<asp:Repeater ID="Repeater1" runat="server" DataSourceID="SqlDataSource1">`

`<ItemTemplate>`

`<asp:Label ID="lblName" runat="server" Text='<%# Eval("au_lname") %>'>        </asp:Label>`

`<br />`

`</ItemTemplate>`

`</asp:Repeater>`

15. 在解决方案资源管理器窗口中右击 AutherListPage.aspx 节点，并选择“设为起始页”。启动调试器。您应该会看到显示有作者姓氏列表的页面。
16. 完成测试后，停止调试器。

使用 ASP.NET GridView 控件显示数据

要使用 ASP.NET GridView 控件显示和更新数据，请遵循以下步骤:

1. 在 Solution Explore 窗口中，右键单击项目节点并选择 Add Add New Item。添加一个 ADO.NET 实体数据模型，并将其命名为 Pubs.edmx。您将收到一条关于将其添加到 App_Code 文件夹的消息。选择是。

2. 在实体数据模型向导中，选择从数据库生成。

3. 在 Chose Your Data Connection 中，您可以重用之前创建的连接，也可以创建一个到 Pubs 数据库的新连接。确保在 Web 中保存实体连接设置。Config，并将其命名为 pubsEntities。

4. In the Choose Your Database Objects and Settings window, select the employee table. Leave the default check boxes checked and name the model pubsModel (see Figure 12-19).

   

   图 12-19 。选择数据对象

5. 完成向导后，您应该在实体设计器中看到 employee 实体。关闭实体设计器，并向设计器添加一个新的 Web 窗体。将页面命名为 EmployeeGridViewPage.aspx。

6. Add a GridView control to the form and add the mark up below. Notice you are setting the ItemType to the employee entity and the SelectMethod to GetEmployees.

   <asp:GridView ID="grdEmployee" runat="server"

   ItemType="employee" SelectMethod="GetEmployees"

   AutoGenerateColumns="false">

   <Columns>

   <asp:BoundField DataField="emp_id" HeaderText="ID" ReadOnly="true" />

   <asp:BoundField DataField="fname" HeaderText="First Name" />

   <asp:BoundField DataField="lname" HeaderText="Last Name" />

   </Columns>

   </asp:GridView>

7. In the code behind file for the page (EmployeeGridViewPage.aspx.cs) add the following code to retrieve the employee data using the employee entity.

   public partial class EmployeeGridViewPage : System.Web.UI.Page

   {

   pubsEntities dbContext = new pubsEntities();

   protected void Page_Load(object sender, EventArgs e)

   {

   }

   public IQueryable<employee> GetEmployees()

   {

   var Employees = dbContext.employees;

   return Employees;

   }

   }

8. 在解决方案资源管理器窗口中右击 EmployeesGridViewPage.aspx 节点，并选择“设为起始页”。启动调试器。您应该会看到显示有员工信息表的页面。

9. 完成测试后，停止调试器。

使用 ASP.NET GridView 控件更新数据

1. Update the GridView control’s mark up to allow updating and set the UpdateMethod attribute to the UpdateEmployee method. The DataKeyNames attribute is set to the unique identifier of the employee entity.

   <asp:GridView ID="grdEmployee" runat="server"

   ModelType="employee" SelectMethod="GetEmployees" DataKeyNames="emp_id"

   AutoGenerateEditButton="true" UpdateMethod="UpdateEmployee"

   AutoGenerateColumns="false">

   <Columns>

   <asp:BoundField DataField="emp_id" HeaderText="ID" ReadOnly="true" />

   <asp:BoundField DataField="fname" HeaderText="First Name" />

   <asp:BoundField DataField="lname" HeaderText="Last Name" />

   </Columns>

   </asp:GridView>

2. In the code behind file for the page (EmployeeGridViewPage.aspx.cs) add the following code to update the employee data using the employee entity. This code looks up the old values held in the entity and tries to update the model. If it is successful it saves the changes back to the database.

   public void UpdateEmployee(employee Employee)

   {

   var Employee2 = dbContext.employees.Find(Employee.emp_id);

   TryUpdateModel(Employee2);

   if (ModelState.IsValid)

   {

   dbContext.SaveChanges();

   }

   }

3. By default Web Forms have UnobtrusiveValidationMode turned on. To implement this you need to add a ScriptManager and some jScript include files. For now you can just turn it off by adding the following to the Page_Load event handler method.

   this.UnobtrusiveValidationMode = System.Web.UI.UnobtrusiveValidationMode.None;

4. 启动调试器。您应该看到显示了一个雇员信息表和一个编辑按钮的页面。单击某行的编辑按钮。这会将网格设置为编辑模式。

5. 更新名字，然后单击“更新”按钮。网格将刷新并显示新值。

摘要

在这一章中，你学习了如何使用基于 Web 表单的前端来实现应用的界面层。在这个过程中，您仔细研究了 .NET 框架，用于实现基于 Web 窗体的用户界面。您还接触了数据绑定 Web 服务器控件，尤其是 GridView 控件。我在这一章的目的是向你展示一些用于开发以数据为中心的 web 应用的技术。要成为一名熟练的 web 开发人员，您需要深入研究这些主题和其他主题，如使用母版页、客户端脚本、使用样式表和 web 安全性。

在第十三章中，你将看到 Windows 8 引入的一种新型应用 Windows Store 应用。Windows 应用商店应用是传统客户端应用和网络应用的混合体。界面使用 HTML 或 XAML 开发，应用逻辑可以用 C#、Visual Basic 或 JavaScript 开发。它们支持越来越流行的触摸屏设备，代表着用户与应用交互方式的转变。

十三、开发 Windows 应用商店应用

在前面的章节中，您学习了如何基于传统的 Windows 客户端(ASP.NET)用户界面和基于 web 的用户界面构建一个以数据为中心的应用。在本章中，您将了解如何使用新的 Windows 应用商店应用构建用户界面。Windows 应用商店应用旨在 Windows 8 设备上运行。Windows 应用商店应用拥有全新的外观，旨在动态支持不同的显示尺寸和设备。随着平板电脑和手机日益成为最受欢迎的信息交互设备，企业用户要求能够使用这些设备与他们的信息存储进行交互。幸运的是，微软提供了各种应用编程接口(API)，可以用来创建在这些设备上运行的应用。他们暴露了一个被管理的 .NET 框架，它允许你使用 C# 来编写代码，使用 XAML 框架来开发用户界面。开发这些应用是开发 WPF 应用和 web 应用的结合。

阅读完本章后，您将能够轻松执行以下任务:

• 使用 XAML 标记设计用户界面
• 使用布局控件
• 使用显示控件
• 响应控制事件
• 使用数据绑定控件

构建用户界面

构建 Windows 应用商店应用的用户界面与开发 WPF 应用非常相似。如果你还记得《??》第十一章，应用的视觉界面包含了对象。与面向对象语言中的大多数对象一样，这些对象公开属性、方法和事件。在 Windows 应用商店应用中，主要对象是页面。一个页面有属性(例如Background属性)、方法(例如focus方法)和事件(例如DoubleTapped事件)。

控件是具有可视化界面的组件，为用户提供了与程序交互的方式。页面是一个容器控件，它承载其他控件。您可以在页面上放置许多不同类型的控件。页面上使用的一些常见控件有文本框、文本块、按钮、列表视图和 GridViews。

就像 WPF 一样，Windows 应用商店用户界面是使用声明性标记语言 XAML 构建的。例如，下面的标记定义了一个Grid中的按钮控件。

<Grid Background="#E5951D1D">
     <Button Content="Button" HorizontalAlignment="Left" Margin="56,124,0,0"
             VerticalAlignment="Top" Background="#FF2457A0"/>

</Grid>

注意Grid需要一个正式的结束标记，因为它包含了Button控件。由于Button控件不包含任何其他控件，您可以在结束括号前使用正斜杠(/)来关闭它。请注意，控件的属性是使用属性语法设置的。

使用网格行和列来绝对或相对定位控件。注意上面的代码使用了按钮在网格中的绝对位置，这是通过使用Margin属性实现的。下面的代码显示了使用网格行和列相对定位的按钮。

<Grid Background="#E5951D1D">
        <Grid.RowDefinitions>
            <RowDefinition Height="140"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>

        <Grid.ColumnDefinitions>
            <ColumnDefinition Width ="140"/>
            <ColumnDefinition Width="*"/>
        </Grid.ColumnDefinitions>

        <Button Content="Button" HorizontalAlignment="Left"
                Grid.Column="1" Grid.Row="1"
                VerticalAlignment="Top" Background="#FF2457A0"
                Height="78" Width="162"/>
    </Grid>

图 13-1 显示了带有由之前的 XAML 代码创建的按钮的页面。

图 13-1 。用 XAML 创造的窗户

如前所述，Grid 控件包含列和行来控制其子控件的位置。列和行的高度和宽度可以设置为固定值、auto 或。自动设置占用所包含控件所需的空间。设置占用尽可能多的可用空间。下面的代码展示了一个用于收集用户信息的简单数据输入表单。生成的表格如图 13-2 中的所示。

<Grid Background="#E5B1BDB9">

            <Grid.RowDefinitions>
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
         <RowDefinition Height="Auto" />
                <RowDefinition Height="*" />
            </Grid.RowDefinitions>
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="200" />
                <ColumnDefinition Width="*" />
            </Grid.ColumnDefinitions>
            <TextBlock Grid.Row="0" Grid.Column="0" Text="Name:"
                   Foreground="Black" VerticalAlignment="Center"
                   Margin="10" FontSize="16"/>
            <TextBlock Grid.Row="1" Grid.Column="0" Text="City:"
                   Foreground="Black" VerticalAlignment="Center"
                   Margin="10" FontSize="16"/>
            <TextBlock Grid.Row="2" Grid.Column="0" Text="State:"
                   Foreground="Black" VerticalAlignment="Center"
                   Margin="10" FontSize="16" />

            <TextBox Grid.Column="1" Grid.Row="0" Margin="3" />
            <TextBox Grid.Column="1" Grid.Row="1" Margin="3" />
            <TextBox Grid.Column="1" Grid.Row="2" Margin="3" />
            <Button Grid.Column="1" Grid.Row="4" HorizontalAlignment="Right"
                    MinWidth="80" MinHeight="50" Margin="0,0,0,8" Content="Submit"
                    Foreground="Black"/>
    </Grid>

图 13-2 。输入表单页面

其他可用的布局控件有StackPanel、WrapGrid和Canvas。下面的代码显示了StackPanel控件中的两个按钮:

<StackPanel Grid.Column="1" Grid.Row="4" Orientation="Horizontal" HorizontalAlignment="right">
        <Button MinWidth="80" MinHeight="50" Margin="0,0,0,8" Content="Submit"
                Foreground="Black"/>
        <Button MinWidth="80" MinHeight="50" Margin="0,0,0,8" Content="Cancel"
                Foreground="Black"/>
</StackPanel>

使用样式表

开发 Windows 应用商店应用的一个重要方面是在页面和应用之间保持一致的外观。界面需要在大显示器和小显示器之间缩放，并平滑地处理方向的变化。这些应用的创建和设计可能是一个耗时、乏味的过程。幸运的是，您可以在应用的所有页面和控件中使用预先构建的样式。这些样式包含在 XAML 文件中，并由使用静态资源标记扩展的控件引用。下面的代码使用静态资源来设置两个按钮控件的样式。

<Button Content="Submit" Style="{StaticResource TextPrimaryButtonStyle}"  />
<Button  Content="Cancel" Style="{StaticResource TextSecondaryButtonStyle}"/>

下列定义样式的标记位于 Common 文件夹中的 StandardStyles.xaml 文件中。请注意，您可以在样式定义中引用样式。

<Style x:Key="TextPrimaryButtonStyle" TargetType="ButtonBase"
        BasedOn="{StaticResource TextButtonStyle}">
        <Setter Property="Foreground"
                   Value="{StaticResource ApplicationHeaderForegroundThemeBrush}"/>
</Style>

处理控制事件

就像 ASP.NET 和 WPF 应用一样，Windows 应用商店应用通过事件与用户互动。不同之处在于事件是如何启动的。虽然 ASP.NET 和 WPF 的应用主要由鼠标和键盘事件驱动，但 Windows Store 应用主要由触摸交互驱动(仍然支持键盘和鼠标事件)。一些常见的交互动作包括点击、按住、滑动和滑动。

在 Visual Studio 中，可以通过编写 XAML 代码或在控件的“属性”窗口中选择事件来将事件添加到控件中。图 13-3 显示了在 XAML 编辑器窗口中连接一个事件处理器；图 13-4 显示了使用属性窗口的事件选项卡连接事件处理程序。请记住，在代码中使用控件时，您需要使用 name 属性为它们指定一个唯一的名称。

图 13-3 。在 XAML 编辑器中连接事件处理程序

图 13-4 。在“属性”窗口中连接事件处理程序

无论如何连接事件处理程序，Visual Studio 代码编辑器都会在代码隐藏文件中插入一个空的事件处理程序方法。以下代码显示了为按钮点击事件插入的事件处理程序方法:

private void btnSubmit_Tapped(object sender, TappedRoutedEventArgs e)
{
}

就像在 WPF 中一样，当事件被触发时，两个参数被传递给方法。第一个参数是发送方，它表示启动事件的对象。第二个参数，在本例中是类型Windows.UI.Xaml.Input.RoutedEventArgs，是一个用于传递特定事件特定信息的对象。下面的代码显示检查他们是否用笔点击。

private void btnSubmit_Tapped(object sender, TappedRoutedEventArgs e)
{
    if (e.PointerDeviceType == PointerDeviceType.Pen)
    {
         //additional code. . .
    }
}

在以下活动中，您将研究如何在简单的 Windows 应用商店应用中使用控件。

活动 13-1。使用控件

在本活动中，您将熟悉以下内容:

• 创建 Windows 应用商店应用
• 设计页面
• 使用控制事件

创建 Windows 应用商店应用界面

要创建应用界面，请遵循以下步骤:

1. 启动 Visual Studio。选择文件新建项目。

2. 单击 Visual C# 模板节点下的 Windows 应用商店节点。选择空白应用模板。将名称更改为 Activity13_1，然后单击“确定”按钮。

3. Open the MainPage.xaml in the design window. Notice it is using the default dark theme. To change this to the light theme, open the App.xaml page. Add the RequestedTheme attribute to the Application mark up.

   <Application

   x:Class="Activity13_1.App"

   xmlns="``http://schemas.microsoft.com/winfx/2006/xaml/presentation

   xmlns:x="``http://schemas.microsoft.com/winfx/2006/xaml

   xmlns:local="using:Activity13_1"

   RequestedTheme="Light">

4. 关闭并重新打开 MainPage.xaml 文件。你现在应该看到一个白色的背景。

5. Update the Grid XAML to define two columns and 5 rows.

   <Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">

   <Grid.ColumnDefinitions>

   <ColumnDefinition Width="300"/>

   <ColumnDefinition Width="Auto"/>

   </Grid.ColumnDefinitions>

   <Grid.RowDefinitions>

   <RowDefinition Height="Auto"/>

   <RowDefinition Height="Auto"/>

   <RowDefinition Height="Auto"/>

   <RowDefinition Height="Auto"/>

   <RowDefinition Height="Auto"/>

   </Grid.RowDefinitions>

   </Grid>

   </Grid>

6. Add the following XAML after the closing Grid.RowDefinitions tag to put two text boxes on the page. One accepts a single line of text and one accepts multiple lines of text.

   <TextBlock Grid.Row="0" Grid.Column="0" Margin="10"

   Style="{StaticResource BasicTextStyle}">

   Single line text input

   </TextBlock>

   <TextBox Grid.Row="0" Grid.Column="1" Margin="10"

   Width="200" HorizontalAlignment="Left"/>

   <TextBlock Grid.Row="1" Grid.Column="0" Margin="10"

   Style="{StaticResource BasicTextStyle}">

   Multi-line input

   </TextBlock>

   <TextBox Grid.Row="1" Grid.Column="1" Margin="10"

   Width="200" Height ="100" TextWrapping="Wrap"

   AcceptsReturn="True" HorizontalAlignment="Left"/>

7. Add a password entry box by inserting the following code.

   <TextBlock Grid.Row="2" Grid.Column="0" Margin="10"

   Style="{StaticResource BasicTextStyle}">

   Password entry

   </TextBlock>

   <PasswordBox Grid.Row="2" Grid.Column="1" Margin="10"

   Width="200" HorizontalAlignment="Left"/>

8. Add two more TextBox controls, one for numeric input and one for email address entry.

   <TextBlock Grid.Row="3" Grid.Column="0" Margin="10"

   Style="{StaticResource BasicTextStyle}">

   Number input

   </TextBlock>

   <TextBox Grid.Row="3" Grid.Column="1" Margin="10"

   Width="200" InputScope="Number"  HorizontalAlignment="Left"/>

   <TextBlock Grid.Row="4" Grid.Column="0" Margin="10"

   Style="{StaticResource BasicTextStyle}" TextWrapping="Wrap">

   Email address

   </TextBlock>

   <TextBox Grid.Row="4" Grid.Column="1" Margin="10"

   Width="200" InputScope="EmailSmtpAddress"  />

9. Note that as you add the XAML, the Visual Designer updates the appearance of the window. The page should look similar to the one shown in Figure 13-5.

   

   图 13-5 。数据输入页面

10. 构建解决方案。如果有任何错误，请修复并重新构建。

11. To test the page, change the debugger target to the Simulator in the toolbar (See Figure 13-6) and start the debugger.

![9781430249351_Fig13-06.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig13-06.jpg)

图 13-6 。启动模拟器

12. When the Simulator launches, change the mode to basic touch (See Figure 13-7). In this mode, the mouse is used to simulate a finger press.

![9781430249351_Fig13-07.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig13-07.jpg)

图 13-7 。改变互动模式

13. 当您在单行输入文本框中按下时，会显示软键盘。输入一些文本并尝试按回车键。您应该不能添加额外的行。测试多行输入和密码输入。
14. 在数字输入框中按。请注意，键盘显示数字键盘。它知道要这样做，因为您向控件添加了InputScope属性。
15. 在电子邮件地址输入框中按会添加“@”和“.”。com "键到键盘上。
16. 完成测试后，您可以通过按 Ctrl + Alt + F4 键来关闭模拟器。

编码控制事件

要对控制事件进行编码，请遵循以下步骤:

1. In the XAML Editor window for the MainPage.xaml file in the Grid.RowDefinitions section add a new row to the grid. In the new row, place two button controls in a stack panel using the code below.

   <StackPanel Grid.Row="5" Grid.Column="1" Orientation="Horizontal">

   <Button Name ="btnSave" Content ="Save"  Margin="10"

   Tapped="btnSave_Tapped"/>

   <Button Name="btnCancel" Content ="Cancel"  Margin="10"

   Tapped="btnCancel_Tapped"/>

   </StackPanel>

2. After the closing StackPanel tag, add the following markup to display a progress ring on the page.

   <ProgressRing x:Name="SaveProgress" Grid.Row="5" Grid.Column="0"

   IsActive="False" Width="113" Height="80"/>

3. 定义上述按钮的 XAML 包括一个用于点击事件的事件处理方法。右键单击 btnSave 的Tapped事件，并在弹出菜单中选择“导航到事件处理程序”。

4. In the Code Editor window of the codebehind file, add the following code to the btnSave_Tapped event handler method. This code makes the progress ring show on the page.

   this.SaveProgress.IsActive = true;

5. In the btnCancel_Tapped method, deactivate the progress ring.

   this.SaveProgress.IsActive = false;

6. 生成解决方案并修复任何错误。

7. 使用模拟器测试按钮的点击事件。

8. 测试完应用后，按 Ctrl + Alt + F4 键关闭模拟器并停止调试。

数据绑定控件

将 Windows Store 应用控件绑定到数据的方式非常类似于在 WPF 的处理方式(在第十章中介绍)。当使用 XAML 进行绑定时，使用每个控件可用的Binding属性。当在代码中绑定控件时，用DataContext属性设置其源。当为父元素(如 Grid 控件)设置 DataContext 时，子元素将使用相同的 DataContext，除非显式设置了它们的 DataContext。

那个 .NET Framework 封装了通过数据绑定过程将控件与数据源同步的大部分复杂性。Mode属性决定了数据绑定如何流动以及如何对数据变化做出反应。一次性绑定在创建绑定时用来自源的数据更新目标。单向绑定会导致对源属性的更改自动更新目标属性，但对目标属性的更改不会传播回源属性。这对于只读情况很有用，并且是默认绑定。双向绑定会导致源属性或目标属性的更改自动更新另一个属性。这对于完全数据更新的情况很有用。

下面的代码显示了设置为包含作者列表的CollectionViewSource的Grid控件的DataContext。CollectionViewSource允许您在作者列表中移动。

cvs = new CollectionViewSource();
cvs.Source = authorList;
this.AuthorList.DataContext = cvs;
cvs.View.MoveCurrentToFirst();

下面的 XAML 代码使用Path属性将包含在Grid控件中的TextBox控件和CheckBox控件绑定到Authors类的属性。使用Binding来指定源数据意味着“查找容器层次结构，直到找到DataContext”在这种情况下，DataContext将是为Grid容器指定的。

<TextBox Grid.Column="1" Grid.Row="2" Height="23" HorizontalAlignment="Left"
                Margin="3" Name="txtLastName" Text="{Binding Path=LastName}"
                VerticalAlignment="Center"  Width="120" />
<CheckBox Name="chkContract" Content="Under Contract"
                IsChecked="{Binding Path=UnderContract}"
                Grid.Row="4" Grid.ColumnSpan="2" FlowDirection="RightToLeft" />

图 13-8 显示了一个包含绑定到作者数据的控件的页面。

图 13-8 。显示作者数据的页面

要浏览记录，只需使用CollectionViewSource View方法。下面的代码显示了如何移动到下一条记录。

cvs.View.MoveCurrentToNext();

虽然有些控件一次只能绑定到一个记录，但其他控件(如GridView控件)可以绑定并显示整个集合。下面的代码将GridView的ItemSource设置为作者列表。在这种情况下，没有必要使用CollectionViewSource。

this.AuthorDataGrid.ItemsSource = authorList;

下面的 XAML 创建了GridView并绑定了视图中包含的控件。结果页面如图 13-9 中的所示。

<GridView Grid.Row="0" Grid.Column="2" x:Name="AuthorGridView"
                  Header="Authors" FontSize="14" FontWeight="Bold" HorizontalAlignment="Center" >
    <GridView.ItemTemplate>
        <DataTemplate>
            <StackPanel Orientation="Horizontal">
                 <TextBlock Text="{Binding FirstName}"
                           Style="{StaticResource ItemTextStyle}" Margin="10"/>
                 <TextBlock Text="{Binding LastName}" TextWrapping="NoWrap"
                           Style="{StaticResource BodyTextStyle}" Margin="10"/>
                 <CheckBox Content="UnderContract" IsChecked="{Binding UnderContract}"
                          IsEnabled="False" Margin="10" FontSize="10"/>
                        </StackPanel>
        </DataTemplate>
    </GridView.ItemTemplate>
</GridView>

图 13-9 。在 GridView 中显示作者数据的页面

在以下活动中，您将构建一个页面，其中包含绑定到一组Author对象的控件。

活动 13-2。使用数据绑定控件

在本活动中，您将熟悉以下内容:

• 将控件绑定到集合
• 研究绑定模式

将控件绑定到集合

要将控件绑定到集合，请遵循以下步骤:

1. 启动 Visual Studio。选择文件新建项目。

2. 选择一个 Windows 应用商店应用，然后选择空白应用模板。将项目重命名为 Activity13_2，然后单击“确定”按钮。

3. 在解决方案资源管理器中右键单击项目节点，然后选择 Add Class。给类命名Author。

4. At the top of the class file, add the following using statement:

   using System.ComponentModel;

5. In the Author class, implement the INotifyPropertyChanged interface. This is needed to facilitate binding.

   class Author : INotifyPropertyChanged

   {

   public event PropertyChangedEventHandler PropertyChanged;

   void RaisePropertyChanged(string propertyName)

   {

   var handler = PropertyChanged;

   if (handler != null)

   {

   handler(this, new PropertyChangedEventArgs(propertyName));

   }

   }

   }

6. Add the following properties. Note that when the values are changed, the PropertyChanged event is raised.

   string _firstName;

   public string FirstName

   {

   get { return _firstName; }

   set

   {

   if (_firstName != value)

   {

   _firstName = value;

   RaisePropertyChanged("FirstName");

   }

   }

   }

   string _lastName;

   public string LastName

   {

   get { return _lastName; }

   set

   {

   if (_lastName != value)

   {

   _lastName = value;

   RaisePropertyChanged("LastName");

   }

   }

   }

   Boolean _underContract;

   public Boolean UnderContract

   {

   get { return _underContract; }

   set

   {

   if (_underContract != value)

   {

   _underContract = value;

   RaisePropertyChanged("UnderContract");

   }

   }

   }

   double _royalty;

   public double Royalty

   {

   get { return _royalty; }

   set

   {

   if (_royalty != value)

   {

   _royalty = value;

   RaisePropertyChanged("Royalty");

   }

   }

   }

7. Add the following constructor to the Author class:

   public Author(string firstName, string lastName,

   Boolean underContract, double royalty)

   {

   this.FirstName = firstName;

   this.LastName = lastName;

   this.UnderContract = underContract;

   this.Royalty = royalty;

   }

8. 构建项目并确保没有错误。如果有，修复它们并重新构建。

9. Open the App.xaml page and add the RequestedTheme attribute to the Application mark up.

   <Application

   x:Class="Activity13_2.App"

   xmlns="``http://schemas.microsoft.com/winfx/2006/xaml/presentation

   xmlns:x="``http://schemas.microsoft.com/winfx/2006/xaml

   xmlns:local="using:Activity13_2"

   RequestedTheme="Light">

10. Add the following XAML markup to the MainPage.xaml file to create the page header:

`<Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">`

`<Grid.RowDefinitions>`

`<RowDefinition Height="140"/>`

`<RowDefinition Height="*"/>`

`</Grid.RowDefinitions>`

`<Grid>`

`<Grid.ColumnDefinitions>`

`<ColumnDefinition Width="Auto"/>`

`<ColumnDefinition Width="*"/>`

`</Grid.ColumnDefinitions>`

`<TextBlock x:Name="PageTitle"`

`Text="Authors" Grid.Column="1"  VerticalAlignment="Center"`

`Margin="120,20,0,0" IsHitTestVisible="false"`

`Style="{StaticResource PageHeaderTextStyle}"/>`

`</Grid>`

`<!-- Add the GridView here -->`

`</Grid>`

11. You can define the DataTemplate under the ResourceDictionary of the Page.Resources section of the page. Add the following XAML markup to define the DataTemplate for the author information contained in the GridView (Add this above the first Grid tag).

`<Page.Resources>`

`<ResourceDictionary>`

`<DataTemplate x:Key="AuthorTemplate">`

`<Grid Background="LightGray"`

`Width="300"`

`Height="200">`

`<Grid.RowDefinitions>`

`<RowDefinition Height="75"/>`

`<RowDefinition Height="Auto"/>`

`<RowDefinition Height="Auto"/>`

`</Grid.RowDefinitions>`

`<StackPanel Orientation="Horizontal" Grid.Row="0">`

`<TextBlock Text="{Binding LastName}"`

`Margin="20,10,0,0"`

`FontSize="24"`

`FontWeight="SemiBold"/>`

`<TextBlock Text="{Binding FirstName}"`

`Margin="20,10,0,0"`

`FontSize="24"/>`

`</StackPanel>`

`<StackPanel Orientation="Horizontal" Grid.Row="1">`

`<TextBlock Text="Royalty: "`

`Margin="20,0,0,0"`

`FontSize="18"/>`

`<TextBlock Text="{Binding Royalty}"`

`Margin="20,0,0,0"`

`FontSize="18"/>`

`</StackPanel>`

`<StackPanel Orientation="Horizontal" Grid.Row="2">`

`<TextBlock Text="Under Contract:"`

`Margin="20,0,0,0"`

`FontSize="18"/>`

`<TextBlock Text="{Binding UnderContract}"`

`Margin="20,0,0,0"`

`FontSize="18"/>`

`</StackPanel>`

`</Grid>`

`</DataTemplate>`

`</ResourceDictionary>`

`</Page.Resources>`

12. Add the GridView to the page to display the author info. Notice the ItemTemplate is set to the AuthorTemplate you defined in step 11.

`<GridView x:Name="AuthorsGridView"`

`Grid.Row="1"`

`Margin="110,50,0,0"`

`SelectionMode="Single"`

`IsSwipeEnabled="True"`

`IsItemClickEnabled="True"`

`ItemsSource="{Binding}"`

`ItemTemplate="{StaticResource AuthorTemplate}">`

`<GridView.ItemsPanel>`

`<ItemsPanelTemplate>`

`<WrapGrid Orientation="Horizontal" />`

`</ItemsPanelTemplate>`

`</GridView.ItemsPanel>`

`</GridView>`

13. In the MainPage.xaml.cs code file, add a class level variable of Type List of Author.

`public sealed partial class MainPage : Page`

`{`

`List<Author> authors;`

14. Add the following method to load the list.

`private void PopulateAuthors()`

`{`

`authors = new List272103_1_En();`

`authors.Add(new Author("Clive", "Cussler", true, .15));`

`authors.Add(new Author("Steve", "Berry", false, .20));`

`authors.Add(new Author("Kate", "Morton", false, .20));`

`authors.Add(new Author("Karma", "Wilson", true, .18));`

`}`

15. In the onNavigatedTo event handler method, call the PopulateAuthors method and set the authors list to the GridView’s ItemSource.

`protected override void OnNavigatedTo(NavigationEventArgs e)`

`{`

`PopulateAuthors();`

`this.AuthorsGridView.ItemsSource = authors;`

`}`

16. To test the page, start the debugger with the Simulator as the target. You should see a page similar to Figure 13-10.

![9781430249351_Fig13-10.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig13-10.jpg)

图 13-10 。GridView 中的作者信息

17. 测试完页面后，按 Ctrl +Alt + F4 键关闭模拟器并停止调试。

研究绑定模式

1. Add another row to the main Grid on the MainPage.

   <Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">

   <Grid.RowDefinitions>

   <RowDefinition Height="140"/>

   <RowDefinition Height="Auto"/>

   <RowDefinition Height="Auto"/>

   </Grid.RowDefinitions>

2. Below the GridView closing tag, add XAML to create a StackPanel with two buttons in it.

   <StackPanel Orientation="Horizontal" Grid.Row="2" VerticalAlignment="Top">

   <Button  Name="btnUpdate" Click="btnUpdate_Click" Content="Update" />

   <Button  Name="btnRefresh" Click="btnRefresh_Click" Content="Refresh" />

   </StackPanel>

3. 上面定义btnUpdate按钮的 XAML 包括一个用于Click事件的事件处理程序方法。右键单击Click事件，并在弹出菜单中选择“导航到事件处理程序”。

4. Add the following code to the Click event handler to update the first author’s last name.

   private void btnUpdate_Click(object sender, RoutedEventArgs e)

   {

   authors[0].LastName = "Webb";

   }

5. Add the following code to the btnRefresh_Click method. This code clears and rebinds the GridView.

   private void btnRefresh_Click(object sender, RoutedEventArgs e)

   {

   this.AuthorsGridView.ItemsSource = null;

   this.AuthorsGridView.ItemsSource = authors;

   }

6. 在模拟器中测试页面。当您单击更新按钮时，第一个作者的名字应该会在页面上更新。这是因为绑定模式默认设置为OneWay。

7. Change the binding mode of the txtFirstName TextBlock to OneTime.

   <TextBlock Text="{Binding FirstName, Mode=OneTime}"

   Margin="20,10,0,0"  FontSize="24"/>

8. 在模拟器中测试页面。当您单击“更新”按钮时，第一作者的姓名不应在页面上更新。这是因为绑定模式被设置为OneTime,，这意味着它只在绑定时才会改变。点击刷新按钮重新绑定DataGrid。您现在应该在GridView中看到新的值。

9. 完成测试后，关闭模拟器并退出 Visual Studio。

页面导航

Windows 应用商店应用中的页面导航在概念上类似于 web 应用中的页面导航。XAML UI 框架提供了一个内置的Frame控件来跟踪导航历史。您可以使用Frame对象的方法，例如GoBack、GoForward和Navigate，轻松地浏览导航历史或跳转到特定页面。Navigation方法还提供了一个参数，允许您在页面之间传递数据。

App.xaml.cs 文件中的以下代码用于在应用启动时导航到应用的主页。如果Frame对象不能导航到MainPage，它抛出一个异常。

if (!rootFrame.Navigate(typeof(MainPage), args.Arguments))
{
    throw new Exception("Failed to create initial page");
}

下面的代码调用Navigate方法导航到一个细节页面，传递一个表示作者的对象，该作者显示在一个GridView项目(e.ClickedItem)中。

private void AuthorsGridView_ItemClick(object sender, ItemClickEventArgs e)
{
    Frame.Navigate(typeof(AuthorDetailPage), e.ClickedItem);
}

AuthorDetailPage 使用事件处理程序OnNavigateTo来检索传递的 author 对象，并将其绑定到AuthorDetails网格的DataContext。

protected override void OnNavigatedTo(NavigationEventArgs e)
{
    author = (Author) e.Parameter;
    this.AuthorDetails.DataContext = author;
}

活动 13-3。使用数据模板

在本活动中，您将熟悉以下内容:

• 实现页面导航
• 在页面之间传递数据

传递数据和页面导航

要实现页面导航，请按照下列步骤操作:

1. 启动 Visual Studio。选择文件打开项目。

2. 选择你在上一次活动中完成的活动 13_2 项目。

3. 项目加载后，添加一个名为 AuthorDetail.xaml 的新空白页。

4. Add the following markup code between the Grid tags in the AuthorDetailPage’s XAML file. This creates the page’s title and adds a back button to the page.

   <Grid.RowDefinitions>

   <RowDefinition Height="140"/>

   <RowDefinition Height="Auto"/>

   </Grid.RowDefinitions>

   <Grid>

   <Grid.ColumnDefinitions>

   <ColumnDefinition Width="Auto"/>

   <ColumnDefinition Width="*"/>

   </Grid.ColumnDefinitions>

   <Button Name="btnBack" Style="{StaticResource BackButtonStyle}"

   Click="btnBack_Click"></Button>

   <TextBlock x:Name="PageTitle"

   Text="Author Info" Grid.Column="1"  VerticalAlignment="Center"

   Margin="120,20,0,0" IsHitTestVisible="false"

   Style="{StaticResource PageHeaderTextStyle}"/>

   </Grid>

5. Add this mark up after the TextBlock tag and before the ending Grid tag shown in step 4. This creates the display controls to display the author’s details.

   <Grid Grid.Row="1" Name="AuthorDetails" DataContext="{Binding Mode=TwoWay}"

   HorizontalAlignment="Left"  Margin="20,0,0,0">

   <Grid.ColumnDefinitions>

   <ColumnDefinition Width="Auto" />

   <ColumnDefinition Width="Auto" />

   </Grid.ColumnDefinitions>

   <Grid.RowDefinitions>

   <RowDefinition Height="Auto" />

   <RowDefinition Height="Auto" />

   <RowDefinition Height="Auto" />

   <RowDefinition Height="Auto" />

   <RowDefinition Height="Auto" />

   </Grid.RowDefinitions>

   <TextBlock Text="First Name:" Grid.Column="0"

   Grid.Row="0" HorizontalAlignment="Left"

   Margin="3" VerticalAlignment="Center" FontSize="18" />

   <TextBox Grid.Column="1" Grid.Row="0" Height="23" HorizontalAlignment="Left"

   Margin="3" Name="txtFirstName" Text="{Binding Path=FirstName}"

   VerticalAlignment="Center" Width="120" FontSize="18" />

   <TextBlock Text="Last Name:" Grid.Column="0" Grid.Row="1"

   HorizontalAlignment="Left" Margin="3" VerticalAlignment="Center" FontSize="18" />

   <TextBox Grid.Column="1" Grid.Row="1" Height="23" HorizontalAlignment="Left"

   Margin="3" Name="txtLastName" Text="{Binding Path=LastName}" IsEnabled="False"

   VerticalAlignment="Center"  Width="120" FontSize="18" />

   <TextBlock Text="Royalty:" Grid.Column="0" Grid.Row="2"

   HorizontalAlignment="Left" Margin="3" VerticalAlignment="Center"            FontSize="18" />

   <TextBox Grid.Column="1" Grid.Row="2" Height="23" HorizontalAlignment="Left"

   Margin="3" Name="txtRoyalty" Text="{Binding Path=Royalty}"

   VerticalAlignment="Center" Width="120" FontSize="18" />

   <CheckBox Name="chkContract" Content="Under Contract"

   IsChecked="{Binding Path=UnderContract}"

   Grid.Row="3" Grid.Column="0" FlowDirection="RightToLeft" FontSize="18" />

   </Grid>

6. In the AuthorDetailPage.xaml.cs file, add the btnBack_Click event handler. This sends the navigation back to the calling page.

   private void btnBack_Click(object sender, RoutedEventArgs e)

   {

   Frame.GoBack();

   }

7. In the MainPage.xaml file, find the AuthorsGridView opening tag and add an ItemClick attribute.

   <GridView x:Name="AuthorsGridView"

   Grid.Row="1"

   Margin="110,50,0,0"

   SelectionMode="Single"

   IsSwipeEnabled="True"

   IsItemClickEnabled="True"

   ItemsSource="{Binding Mode=OneTime}"

   ItemTemplate="{StaticResource AuthorTemplate}"

   ItemClick="AuthorsGridView_ItemClick">

8. In the MainPage.xaml.cs file, add the AuthorsGridView_ItemClick event handler. This causes the application to navigate to the AuthorDetailPage.

   private void AuthorsGridView_ItemClick(object sender, ItemClickEventArgs e)

   {

   Frame.Navigate(typeof(AuthorDetailPage));

   }

9. 在模拟器中测试导航。当MainPage显示时，点击其中一个显示作者信息的灰色方框。应该显示AuthorDetailPage。点击返回按钮，这将带您回到MainPage。测试后，关闭模拟器。

在页面间传递数据

1. In the MainPage.xaml.cs file, update the AuthorsGridView_ItemClick event handler to pass the e.ClickedItem which represents an Author object to the AuthorDetailPage.

   private void AuthorsGridView_ItemClick(object sender, ItemClickEventArgs e)

   {

   框架。navigate(type of(author detail page)，e . ClickedItem)；

   }

2. In the AuthorDetailPage.cs file, add the following code to the OnNavigatedTo event handler. This code takes the parameter passed to the page and assigns it to the DataContext of the AuthorDetails grid.

   protected override void OnNavigatedTo(NavigationEventArgs e)

   {

   作者 author = (Author) e .参数；

   这个。author details . data context = author；

   }

3. 在模拟器中测试应用。当MainPage显示时，点击其中一个显示作者信息的灰色方框。AuthorDetailsPage应该显示加载到页面控件中的作者信息。测试后，关闭模拟器。

摘要

在本章中，您了解了如何使用新的 Windows 应用商店应用实现应用的界面层。您了解了如何使用 XAML 创建页面和布局控件。您还看到了将控件绑定到数据并呈现给用户是多么容易。这个故事还缺少关于如何从服务器上的关系数据库中检索数据的信息。为了向 Windows 应用商店应用提供服务器端数据，您需要利用 web 服务。在第十四章中，你将会看到使用 ASP.NET 通信框架(WCF)和新的 web API 来创建 Web 服务。您还将看到在客户机应用中使用 web 服务。

十四、开发和使用 Web 服务

在前三章中，您研究了创建应用的图形用户界面所需的步骤。使用 ASP.NET WPF 和 Windows 应用商店应用创建的图形用户界面为用户提供了一种与您的应用交互和使用应用提供的服务的方式。本章向您展示了如何构建另一种类型的接口，这种接口是使用 web 服务协议实现的，旨在供应用使用。这种服务为应用提供了一个可编程的接口来访问其功能，而不需要人工交互。您将首先看到创建和消费 Windows 通信基础(WCF) web 服务。WCF 服务是健壮的服务，支持多种协议上的安全消息传递。当您既要负责服务提供者又要负责服务消费者时，WCF 服务是一个很好的选择，例如，在公司的内部网上提供消费服务。您还将了解如何创建和使用 ASP.NET Web API 服务。ASP.NET Web API 提供了一个轻量级协议，用于通过 HTTP 在客户机和服务器之间传递数据。对于通过互联网在使用不同技术和/或不同组创建的客户端和服务器之间传递数据，这是一个更好的选择。

阅读完本章后，您将对以下内容有更清晰的理解:

• 什么是 web 服务以及它们是如何产生的
• WCF 如何处理服务请求
• 如何创建和消费 WCF 服务
• ASP.NET Web API 服务如何处理服务请求
• 如何创建和使用 ASP.NET Web API 服务

什么是服务？

微软首次引入服务的概念是在 .NET 框架 1.0。web 服务为应用提供了一种请求服务和接收回复的方式。这本质上与客户机对象向应用边界内的服务器对象请求服务(方法)是一样的。区别在于客户端对象和服务器对象的位置。如果它们驻留在同一个应用中，那么它们可以发送和接收二进制消息，并且可以相互理解，因为它们说的是同一种“语言”随着您构建的应用变得越来越复杂，通常会将应用分成不同的组件。当您将一个应用分割成多个组件，每个组件都被设计来执行一个独特的专门服务时，您可以极大地增强代码的可维护性、可重用性和可靠性。此外，单独的服务器可以托管各种组件，以提高性能、更好地维护和安全性。

在引入 web 服务之前，应用的客户机和服务器依靠分布式技术进行通信，如微软的分布式组件对象模型(DCOM)和对象管理小组(OMG)的通用对象请求代理体系结构(CORBA)。如果客户机和服务器应用使用相同的技术，这些早期的面向服务的体系结构的尝试工作得相当好，但是当客户机和服务器使用不同的技术时，它就变得非常成问题。web 服务的强大之处在于它们使用一组开放的消息传递和传输协议。这意味着使用不同技术的客户端和服务器组件可以以标准的方式进行通信。例如，运行在 Apache web 服务器上的基于 Java 的应用可以向运行在 IIS 服务器上的基于. NET 的应用请求服务。此外，他们几乎可以位于世界上任何有互联网连接的地方。

WCF 网络服务

随着。在. NET Framework 3.0 中，微软引入了一种以 Windows Communication Foundation services(WCF)的形式创建 web 服务的新方法。在 WCF 之前，微软有一套强大但混乱的消息传递技术，包括 ASP.NET 网络服务、MSMQ、企业服务和 .NET 远程处理。微软决定将所有这些技术整合到一个开发面向服务的应用的框架中。这使得开发面向服务的应用更加一致，减少了开发人员的困惑。

WCF 服务由三部分组成:服务、端点和托管环境。服务是一个类，包含您希望向服务的客户端公开的方法。端点是客户端如何与服务通信的定义。值得注意的是，一个服务可以定义多个端点。一个端点由服务的基址地址，它的绑定信息，以及它的契约信息组成(这三者通常被称为 WCF 的 ABC)。托管环境指的是托管服务的应用。出于您的目的，这将是一个 web 服务器，但是根据您实现的 WCF 服务的类型，还存在其他选项。

创建 WCF Web 服务

使用 Visual Studio 2012 创建和消费基本的 WCF 服务是一个相当简单的过程。如果您使用 Visual Studio 提供的模板，大部分的管道工作已经为您完成了。图 14-1 显示了可用的模板。要创建 WCF web 服务，您可以使用 WCF 服务应用模板。

图 14-1 。Visual Studio 提供的 WCF 模板

选择一个模板会向项目添加两个重要文件:一个使用接口定义服务契约，另一个是包含服务实现代码的类文件。在图 14-2 中，IService1.cs 文件定义了接口，Service1.svc.cs 包含了服务的类实现。

图 14-2 。WCF 接口和类文件

当您创建服务时，您需要定义服务契约。契约由接口定义来定义。该接口定义服务公开的方法、方法预期的任何输入参数以及方法传回的任何输出参数。以下代码显示了税务服务的接口代码。接口用[ServiceContract]属性标记，任何公开的方法用[OperationContract]标记。

[ServiceContract]
public interface ITax
{
    [OperationContract]
    double GetSalesTax(string statecode);
}

一旦定义了接口，下一步就是定义实现接口的类。下面的代码实现了ITax接口，并提供了实现其公开方法的代码。

public class Tax : ITax
{
    public double GetSalesTax(string stateCode)
    {
        if (stateCode == "PA")
        {
            return .06;
        }
        else
        {
            return .05;
        }
    }
}

一旦定义了接口和类，编译并运行应用就产生了如图图 14-3 所示的测试客户端。您可以通过输入状态代码并单击 Invoke 按钮来测试 web 服务。点击 XML 选项卡显示客户端和服务器之间发送的请求和响应消息，如图图 14-4 所示。

图 14-3 。测试网络服务

图 14-4 。请求和响应消息

消费 WCF 网络服务

要在. NET 客户端中使用 WCF 服务，必须向项目中添加服务引用。当您在 Visual Studio 2012 中添加服务引用时，您会看到一个添加引用窗口(参见图 14-5 )。此窗口允许您发现可用的服务及其公开的操作。您还可以更改用于针对服务进行编程的命名空间。

图 14-5 。添加服务引用

一旦服务引用被添加到项目中，Visual Studio 就会用调用服务所需的信息更新应用配置文件。这包括带有地址、绑定和契约信息的端点配置。

<endpoint address="
http://localhost:49185/TaxService.svc
" binding="basicHttpBinding"
                bindingConfiguration="BasicHttpBinding_ITaxService" contract="TaxService.                ITaxService"
                name="BasicHttpBinding_ITaxService" />

客户端代理也被添加到客户端应用中。客户端应用使用这个代理与服务进行交互。以下代码显示了一个客户端控制台应用使用 TaxServiceClient 代理调用服务，并将结果写入控制台窗口。图 14-6 显示了控制台窗口的输出。

TaxService.TaxServiceClient webService = new TaxService.TaxServiceClient();
string state1 = "PA";
double salesTax1 = webService.GetSalesTax(state1);
Console.WriteLine("The sales tax for {0} is {1}", state1, salesTax1);
string state2 = "NJ";
double salesTax2 = webService.GetSalesTax(state2);
Console.WriteLine("The sales tax for {0} is {1}", state2, salesTax2);
webService.Close();
Console.ReadLine();

图 14-6 。调用 TaxService 的输出

使用数据协定

在前面的示例中，WCF web 服务仅使用简单类型在服务和客户端之间来回传递数据。整数、双精度和字符串等简单类型不需要任何特殊的编码就可以在客户端和服务器之间传递。有时候，您希望在客户机和服务器之间传递复杂的类型。复杂类型由简单类型组成。例如，您可能有一个服务，它采用由街道、城市、州和邮政编码组成的地址类型，并返回由经度和纬度组成的位置类型。为了促进复杂类型的交换，WCF 服务使用数据契约。像往常一样创建数据类，然后用[DataContract]属性标记它。您想要公开的类的属性被标记为[DataMember]属性。下面的代码向服务的客户端公开了Location类:

[DataContract]
public class Location
{
    double _longitude;
    double _latitude;
    [DataMember]
    public double Latitude
    {
        get { return _latitude; }
        set { _latitude = value; }
    }
    [DataMember]
    public double Longitude
    {
        get { return _longitude; }
        set { _longitude = value; }
    }
}

通过用[DataContract]和[DataMember]属性标记类，创建了一个描述复杂类型的 XML 模式定义(XSD)文件。客户端使用这个文件来确定提供什么服务以及期望什么作为返回类型。以下标记显示了为服务返回的Location类型创建的 XSD 文件部分。

<xs:complexType name="Location">
    <xs:sequence>
      <xs:element minOccurs="0" name="Latitude" type="xs:double" />
      <xs:element minOccurs="0" name="Longitude" type="xs:double" />
    </xs:sequence>
  </xs:complexType>
<xs:element name="Location" nillable="true" type="tns:Location" />

在以下活动中，您将创建一个 WCF 服务，并在. NET 客户端应用中使用该服务。

活动 14-1。创建和消费 WCF 服务

在本活动中，您将熟悉以下内容:

• 创建 WCF 服务
• 在客户端应用中使用 WCF 服务

创建 WCF 服务

要创建 WCF 服务，请执行以下步骤:

1. 启动 Visual Studio。选择文件新建项目。

2. Choose WCF under the Visual C# Templates folder and select the WCF Service Application project type. Rename the project to Activity14_1 and click the OK button. (See Figure 14-7)

   

   图 14-7 。创建 WCF 服务应用

3. 删除 IService1.cs 和 Service1.svc 文件。在解决方案资源管理器中右键单击项目节点，并选择 Add New Item。在“添加新项目”对话框中，选择 WCF 服务。将服务命名为 DiscountService。

4. Open the IDiscountService.cs file in the code editor. Replace the DoWork operation contract with a GetDiscount operation contact.

   [ServiceContract]

   public interface IDiscountService

   {

   [OperationContract]

   double GetDiscount(string discountCode);

   }

5. Open the DiscountService.svc.cs file in the code editor. Replace the DoWork method with the following GetDiscount method.

   public class DiscountService : IDiscountService

   {

   public double GetDiscount(string discountCode)

   {

   if (discountCode == "XXXX")

   {

   return 20;

   }

   else

   {

   return 10;

   }

   }

   }

6. 构建项目。如果有任何错误，请修复它们，然后重新构建。

7. 确保在解决方案资源管理器中选择 DiscountService.svc 节点，并启动调试器。您应该会看到 WCF 测试客户端。测试GetDiscount操作。完成测试后，关闭 WCF 测试客户端。

创造。网络客户端

1. 在解决方案资源管理器中，右键单击 Activity14_1 解决方案节点，并选择 Add New Project。在 Windows 模板下添加一个名为 OfficeSupply 的 WPF 应用。

2. Add the following XAML to the MainWindow between the Grid tags.

   <TextBlock Text="Discount Code:" FontSize="20" Margin="10,25,350,250"/>

   <TextBox Name="txtDiscountCode" FontSize="20" Margin="160,25,100,250"/>

   <Button Name="btnGetDiscount" Content="Get Discount" Width="150"

   FontSize="20" Margin="150,75,213,200" />

3. In the Solution Explorer, right-click the OfficeSupply project node and select Add Service Reference. In the Add Service Reference dialog, click the Discover button. You should see the DiscountService.svc as shown in Figure 14-8. Click the OK button to add the reference.

   

   图 14-8 。添加服务引用

   注意您的服务地址在本地开发时端口号可能会发生变化。

4. 将 Click 事件处理程序方法添加到 btnGetDiscount 中。

5. Add the following code to the click event handler. It is usually good practice to call web services asynchronously so the client application remains responsive while waiting for the response. Remember from Chapter 8 you need to use the await key word when calling an async method and also add the async key word to the method you are calling it from.

   private async void btnGetDiscount_Click(object sender, RoutedEventArgs e)

   {

   ServiceReference1.DiscountServiceClient service =

   new ServiceReference1.DiscountServiceClient();

   double discount = await service.GetDiscountAsync(txtDiscountCode.Text);

   MessageBox.Show(discount.ToString());

   }

6. In the Solution Explorer, right-click the Activity14_1 solution node and select Properties. Click on the Startup Project node and select Multiple startup projects. Make sure the Action of each project is set to Start and click OK to continue. (See Figure 14-9)

   

   图 14-9 。设置启动项目

7. Start the debugger. When the form shows enter a discount code of “XXXX” and click the Get Discount button. You should see a message box showing 20 (see Figure 14-10). Try a different code; you should see a discount of 10. When finished testing, stop the debugger and exit Visual Studio.

   

   图 14-10 。测试折扣 web 服务

RESTful 数据服务

尽管 WCF 是构建 web 服务的一项伟大技术，但是在客户端和服务器之间传递消息时，它包含了大量的开销。当客户端和服务器来回传递数据时，这一点尤其明显。不仅传递数据，还传递描述数据的所有元数据。通常，正在传输的实际数据只占正在发送的消息的很小一部分。通常并不需要所有这些元数据，事实上，当客户端和服务器使用不同的编程框架和不同类型的系统构建时，强类型化数据可能会导致问题。这就是基于表述性状态转移(REST)的服务派上用场的地方。

RESTful web 服务使用 HTTP 上的简单通信，并使用普通的旧 XML (POX )或 JavaScript 对象符号(JSON)交付数据。使用标准的 HTTP 动词 GET、PUT、POST 和 DELETE 来访问和更改数据。微软开发了 ASP.NET WEB API 作为 WCF 的 RESTful 替代品。它不会取代 WCF，但当您不需要支持 TCP 和 UDP 之类的传输协议或支持二进制编码时，它是 WCF 的一个不错的轻量级替代方案。这对于以松散耦合的方式将数据从客户机传递到服务器非常有用。因此，虽然 ASP.NET Web API 服务在将应用逻辑(方法)公开为服务方面非常有用，但在公开数据方面却非常出色。

创建 ASP.NET Web API 服务

当创建 ASP.NET Web API 服务时，您需要创建一个 Web 应用来托管该服务。一旦创建了 web 应用，就可以添加一个 Web API 控制器类。Web API 控制器类提供了处理请求消息、与数据模型交互以及生成响应消息所必需的功能。例如，当您想要请求一个雇员列表时，您可以请求下面的 URI。

http://localhost/DemoChapter14/employees

其中localhost是 web 服务器的名称，DemoChapter14 是 web 应用的名称，employees 是控制器的名称。这个 URI 被映射到控制器的 get 方法，该方法返回包含雇员数据的字符串数组。根据请求，输出可以是 POX 或 JSON 的形式。

如果你想得到一个雇员的数据，你可以使用同一个 URI，并在末尾加上雇员键。

http://localhost/DemoChapter14/employees/10

这被映射到控制器上的一个Get`方法，该方法有一个整数类型的输入参数。

public string Get(int id)
{
            //Retrieve employee data
 }

要将 URI 请求映射到 Web API 控制器类的适当方法，您需要将以下代码添加到 Global.asax.cs 文件中的 Application_Start 事件处理程序。这段代码将映射信息添加到RouteTable中。

RouteTable.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "DemoChapter14/{controller}/{id}",
                defaults: new
                {
                    id = RouteParameter.Optional
                }
            );

在下面的活动中，您将创建一个 Web API 服务，该服务从 Pubs 数据库中提供图书数据。

活动 14-2。创建 WEB API 服务

在本活动中，您将熟悉以下内容:

• 创建 Web API 服务

要创建 Web API 服务，请按照下列步骤操作:

1. 启动 Visual Studio。选择文件新建项目。

2. Choose Web under the Visual C# Templates folder and select the ASP.NET Empty Web Application project type. Rename the project to Activity14_2 and click the OK button. (See Figure 14-11)

   

   图 14-11 。添加空的 Web 应用项目

3. 右键单击活动 14_2。Web 项目节点，并选择 Add New Folder。命名文件夹模型。

4. 右键单击解决方案资源管理器窗口中的模型文件夹，并选择 Add New Item。在“添加新项”窗口的“数据”节点下，选择一个 ADO.NET 实体数据模型。将模型命名为 Pubs.edmx，然后单击 Add。

5. 在选择模型内容屏幕中，选择从数据库生成选项，然后单击下一步。

6. 在“选择您的数据连接”屏幕中，选择一个现有连接或创建一个到 Pubs 数据库的新连接，然后选择“下一步”。

7. 在“选择数据库对象”屏幕中，展开“表”节点；选择标题表；然后单击完成。

8. 在解决方案资源管理器窗口中右键单击 Activity14_2 web 项目节点，并选择 Add New Folder。命名文件夹控制器。

9. 在 Solution Explorer 窗口中右键单击 Controllers 文件夹，并选择 Add New Item。在“添加新项”窗口中，单击已安装模板中的 web 节点。选择 Web API 控制器类模板，将其重命名为BooksController，并单击 Add 按钮。

10. Open the BooksController.cs file in the Code Editor. Add the following using statement to the top of the file.

`using Activity14_2.Model;`

11. Update the code so that the Get method uses LINQ to EF (Chapter 10) to retrieve an array of books and sends it back to the caller.

`// GET api/<controller>`

`public IEnumerable<title> Get()`

`{`

`var context = new pubsEntities();`

`var query = from t in context.titles select t;`

`var titles = query.ToArray<title>();`

`return titles;`

`}`

12. 在解决方案资源管理器窗口中右键单击 Activity14_2 web 项目节点，并选择 Add New Item。在“添加新项”窗口中，单击已安装模板中的 web 节点。选择全局应用类模板。将其命名为 Global.asax。
13. In the Global.asax.cs file add the following using statements.

`using System.Web.Routing;`

`using System.Web.Http;`

14. In the Application_Start event handler add the following code to map the URI verbs (Get, Put, etc.) to the BooksController methods.

`RouteTable.Routes.MapHttpRoute(`

`name: "DefaultApi",`

`routeTemplate: "Activity14_2/{controller}/{id}",`

`defaults: new`

`{`

`id= RouteParameter.Optional`

`}`

`);`

15. Build the solution. If there are any errors, fix them and rebuild. Figure 14-12 shows the project files in Solution Explorer.

![9781430249351_Fig14-12.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig14-12.jpg)

图 14-12 。查看项目文件

16. Launch the debugger. In the browser window, type the following URI (http://LocalHost:port/Activity14_2/books). Replace the port with the port number of your project. You can find the port number by right clicking the project node in Solution Explorer and selecting properties. The project URL should be listed on the Web tab (See Figure 14-13).

![9781430249351_Fig14-13.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig14-13.jpg)

图 14-13 。查找端口号

17. You should get a message asking if you want to open or save books.json. Open the file in Notepad. You should see the book information listed in JSON format (see Figure 14-14).

![9781430249351_Fig14-14.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig14-14.jpg)

图 14-14 。在记事本中查看 books.json 文件

18. 完成测试后，停止调试器并退出 Visual Studio。

使用 ASP.NET Web API 服务

当客户端应用调用 ASP.NET Web API 服务时，它需要发出 HTTP 请求，并等待 POX 或 JSON 文本流形式的响应数据。收到响应后，客户端解析文本文件，并将数据加载到本地对象中进行处理。由于元数据不随数据一起传递，Visual Studio 无法自动生成代理对象供客户端使用。

名称空间中的 HttpClient 类用于发送请求和接收来自 Web API 服务的响应。下面的代码演示了如何使用HttpClient类从 web 服务请求图书列表。首先实例化一个HttpClient对象并设置基址。

private HttpClient httpClient;
httpClient = new HttpClient();
httpClient.BaseAddress = new Uri("
http://localhost:49213/
");

一旦设置了基址，就可以设置想要返回的响应的格式。在这种情况下，需要一个 JSON 响应。

httpClient.DefaultRequestHeaders.Accept.Add
                (new MediaTypeWithQualityHeaderValue("application/json"));

然后，您可以发出请求并等待响应。因为这可能需要一段时间，所以您应该异步调用 web 服务。

var response = await httpClient.GetAsync("Activity14_2/books");

当响应返回时，您可以使用Windows.Data.Json名称空间中的JsonArray类解析文本(当前随 Windows 8 一起提供),并将其加载到本地对象/集合中进行处理。

var bookJSON = await response.Content.ReadAsStringAsync();
var bookArray = JsonArray.Parse(bookJSON);
ObservableCollection<Book> bc = new ObservableCollection<Book>();
foreach (var b in bookArray)
{
    Book bk = new Book();
    bk. title_id=b.GetObject()["title_id"].GetString();
    bk.title = b.GetObject()["title"].GetString();
    bk.type = b.GetObject()["type"].GetString();
    bc.Add(bk);
}

使用各种 Web API 服务 .NET 客户端(ASP.NET WPF 和一个 Windows 应用商店)是一个非常相似的过程。在以下活动中，您将从 Windows 应用商店应用调用您在活动 14-2 中创建的 web 服务。

活动 14-3。调用 WEB API 服务

在本活动中，您将熟悉以下内容:

• 调用 Web API 服务

要调用 Web API 服务，请按照下列步骤操作:

1. 启动 Visual Studio 并打开活动 14-2 中的项目。将名为 BookServiceClient 的新 Windows 应用商店空白应用添加到解决方案中。

2. Add a new class to the BookServiceClient named Book and add the following properties to the class.

   class Book

   {

   public string Title_id { get; set; }

   public string Title { get; set; }

   public string Type { get; set; }

   public string Notes { get; set; }

   }

3. Open the MainPage.xaml file in the designer. Add the following XAML markup between the Grid tags to define a GridView to display a collection of book data.

   <GridView Name="BooksView" ItemsSource="{Binding}" Margin="50,50,0,0">

   <GridView.ItemTemplate>

   <DataTemplate>

   <StackPanel Width="300" Height="300" Margin="10"                 Background="#FF161C8F">

   <TextBlock Margin="10,0" Text="{Binding Title_id}" />

   <TextBlock Margin="10,0" Text="{Binding Title}" />

   <TextBlock Margin="10,0" Text="{Binding Type}" />

   <TextBlock Margin="10,0" Text="{Binding Notes}"                     TextWrapping="Wrap"/>

   </StackPanel>

   </DataTemplate>

   </GridView.ItemTemplate>

   </GridView>

4. Open the MainPage.xaml.cs file in the code editor window. Add the following using statements to the top of the file.

   using System.Net.Http;

   using System.Net.Http.Headers;

   using Windows.Data.Json;

   using System.Collections.ObjectModel;

5. Add a class level HttpClient variable to the class and update the class constructor with the following code. Replace the port number with the port number being used by your web service.

   private HttpClient httpClient;

   public MainPage()

   {

   this.InitializeComponent();

   httpClient = new HttpClient();

   httpClient.BaseAddress = new Uri("``http://localhost:49213/

   httpClient.DefaultRequestHeaders.Accept.Add

   (new MediaTypeWithQualityHeaderValue("application/json"));

   }

6. Add an asynchronous method that calls the web service, parses the result, and binds it to the GridView.

   private async void GetBooks()

   {

   var response = await httpClient.GetAsync("Activity14_2/books");

   if (response.IsSuccessStatusCode)

   {

   var bookJSON = await response.Content.ReadAsStringAsync();

   var bookArray = JsonArray.Parse(bookJSON);

   ObservableCollection<Book> bc = new ObservableCollection<Book>();

   foreach (var b in bookArray)

   {

   Book bk = new Book();

   bk.Title_id=b.GetObject()["title_id"].GetString();

   bk.Title = b.GetObject()["title1"].GetString();

   bk.Type = b.GetObject()["type"].GetString();

   bk.Notes = b.GetObject()["notes"].Stringify();

   bc.Add(bk);

   }

   this.BooksView.DataContext = bc;

   }

   }

7. In the OnNavigatedTo event handler call the GetBooks method.

   protected override void OnNavigatedTo(NavigationEventArgs e)

   {

   GetBooks();

   }

8. 构建解决方案。如果有任何错误，请修复并重新构建。

9. In the Solution Explorer, right-click the Activity14_2 solution node and select Properties. Click on the Startup Project node and select Multiple startup projects. Make sure the Action of each project is set to Start. (See Figure 14-15).

   

   图 14-15 。设置启动项目

10. Launch the debugger. You should see the book information listed in the GridView. (See Figure 14-16).

![9781430249351_Fig14-16.jpg](https://gitee.com/OpenDocCN/vkdoc-csharp-zh/raw/master/docs/begin-cs-oop/img/9781430249351_Fig14-16.jpg)

图 14-16 。显示图书信息

11. 完成测试后，按 Alt + F4 键关闭应用。在 Visual Studio 中，停止调试器并退出 Visual Studio。

摘要

在本章中，您已经了解了实现 web 服务的基础知识。特别是，您看到了如何使用 ASP.NET web API 和 Windows 通信框架(WCF)创建 Web 服务。您还构建了调用这些 web 服务的客户端应用。

这是旨在向您展示各种技术和 .NET 框架类来构建 .NET 应用。这些章节仅仅触及了这些技术的表面。随着开发经验的积累 .NET 应用，您将需要更深入地研究这些技术。

到目前为止，您已经学习了 UML 设计、面向对象编程、C# 语言、 .NET 框架、创建图形用户界面和开发 Web 服务。现在，您已经准备好将这些部分放在一起，开发一个可工作的应用。在第十五章的中，你将重温你为第四章中介绍的案例研究开发的 UML 模型。您将把这些模型转换成一个功能应用。`

十五、开发办公用品订购应用

在前面的章节中，你看到了三种开发应用图形用户界面的方法。图形用户界面为人类用户提供了一种与您的应用进行交互并使用它们所提供的服务的方式。您还看到了服务如何创建编程接口，其他程序可以调用这些接口来使用应用的服务，而无需任何用户交互。

在这一章中，你兜了一圈，回到了你在第四章中设计的办公用品订购应用(简称 OSO)。这一章是一个大活动，也是一次期末考试。您将创建一个功能性的应用，其中包含了您在前面章节中学到的概念。在创建应用的过程中，您应该能够识别这些概念，并将它们与前面介绍的概念联系起来。该应用将包含数据访问层、业务逻辑层和用户界面层。

读完这一章，你会明白为什么应用被分成不同的层，以及如何构造它们。

重温应用设计

设计应用时，通常可以分三个不同的阶段进行。首先，你完成概念设计，然后是逻辑设计，最后是物理设计。

如第四章所述，概念设计 构成了该过程的发现阶段。概念设计阶段涉及系统用户和系统设计者之间大量的合作和交流。系统设计者必须完全理解被提议的系统将包含的业务过程。使用场景和用例，设计者定义系统的功能需求。此阶段的必要成果是系统的开发人员和用户对系统功能和范围达成共识。

设计过程的第二阶段是逻辑设计。在逻辑设计阶段，你要设计出系统结构和组织的细节。这个阶段包括组成系统的业务对象和类的开发和识别。UML 类图标识了系统对象，您可以为这些对象标识和记录属性和行为。您还可以使用类图开发和记录这些对象的结构依赖性。使用序列图和协作图，您可以发现和识别各种系统对象之间的交互和行为依赖。这个阶段的结果，即应用对象模型，独立于任何特定于实现的技术和部署架构。

设计过程的第三阶段是物理设计。在物理设计阶段，您将应用对象模型转换成实际的系统。您评估并决定特定的技术和基础结构，进行成本分析，并确定任何限制。诸如程序员经验和知识基础、当前的实现技术和遗留系统集成等问题都会影响您在物理设计阶段的决策。您还必须分析安全问题、网络基础设施和可伸缩性要求。

设计分布式应用时，通常将其逻辑架构结构与物理架构结构分开。通过以这种方式分离架构结构，您会发现维护和更新应用要容易得多。您可以在影响最小的情况下进行任何物理架构更改(例如，提高可伸缩性)。逻辑架构设计通常将应用的各个部分分成不同的层。用户与表示层交互，表示层向用户呈现数据，并为用户提供发起业务服务请求的方法。业务逻辑层封装并实现了应用的业务逻辑。它负责执行计算、处理数据、控制应用逻辑和序列。数据层负责管理对信息的访问和存储，这些信息必须在不同的用户和业务流程之间持久化和共享。图 15-1 显示了一个典型的三层应用的不同逻辑层。

图 15-1 。三层应用的逻辑层

当您创建应用的物理层时，理想情况下，每个逻辑层都对应于其专用服务器上的一个不同的物理层。实际上，应用的物理层受到可用硬件和网络基础设施等因素的影响。您可能将所有逻辑层都放在一台物理服务器上，或者分布在 web 和数据库服务器上。重要的是，您创建的应用在类之间实现了明确的职责分离。

图 15-2 显示了 OSO 应用的建议布局。为了简单起见，您将在同一个程序集中创建业务逻辑类和数据访问类。该组件被称为业务逻辑层(BLL)，而用户界面层包含在它自己的组件用户界面层(UI)中。两个程序集都包含在同一台服务器(您的计算机)上。需要记住的重要一点是，由于业务逻辑类和数据访问类之间有明确的职责分离，随着应用功能和用户的增加，它可以很容易地重构为托管在不同服务器上的不同程序集。

图 15-2 。OSO 应用的物理层

构建 OSO 应用的数据访问层

为了开发应用的业务逻辑和数据访问层，你需要回顾你在第四章中创建的 OSO 类图(如图 15-3 所示)。

图 15-3 。OSO 应用类图

正如第四章所讨论的，你需要创建一个Employee类来实现一个登录方法(Login())。登录方法将与数据库交互，以验证登录信息。为此，您将创建两个雇员类:一个用于业务逻辑层(Employee)，一个用于数据访问层(DALEmployee)。Employee类将把来自用户界面(UI)的登录请求传递给DALEmployee类，后者将与数据库交互以检索所请求的信息。图 15-4 是办公用品数据库的数据库模式。此数据库驻留在 SQL Server 数据库中。

图 15-4 。办公用品数据库图表

注如果您没有安装办公用品数据库，请参见附录 C 获取说明。

首先，您将从数据访问层开始，然后实现业务逻辑层。

在 Visual Studio 中，创建一个类库应用，命名为 OfficeSupplyBLL，将解决方案命名为 OfficeSupply，如图图 15-5；该应用将包含 OSO 应用的业务逻辑层和数据访问层的类。

图 15-5 。创建 OfficeSupplyBLL 类库

注意如果你不想从头开始编写办公用品订购应用，你可以从 Apress 网站下载。详见附录 C 。

接下来，您将创建一个静态类(DALUtility)，它实现从 App.config 文件中检索数据库连接字符串。其他类将调用它的GetSQLConnection来检索连接字符串。

将 App.config 文件添加到项目中。在 App.config 文件中，添加下面的 xml 代码来设置连接信息。请记住，根据您的服务器设置，您可能需要更改数据源。

<configuration>
  <connectionStrings>
    <add name="OSConnection"
      providerName="System.Data.SqlClient"
      connectionString="data source=localhost;initial catalog=OfficeSupply;
                       integrated security=True;"/>
  </connectionStrings>
 </configuration>

在“解决方案资源管理器”窗口中，右击“引用”文件夹并选择“添加引用”。在框架组件中，选择System.Configuration组件，如图图 15-6 所示。

图 15-6 。添加对应用的引用

向项目中添加一个类，并将其命名为DALUtility。将以下代码添加到类文件中:

using System;
using System.Configuration;

namespace OfficeSupplyBLL
{
    public static class DALUtility
    {
        public static string GetSQLConnection(string name)
        {
            // Assume failure.
            string returnValue = null;

            // Look for the name in the connectionStrings section.
            ConnectionStringSettings settings
                = ConfigurationManager.ConnectionStrings[name];

            // If found, return the connection string.
            if (settings != null)
            {
                returnValue = settings.ConnectionString;
            }
            return returnValue;
        }
    }
}

下一个要添加的类是DALEmployee类。这个类包含一个Login方法，用于检查提供给数据库中的值的用户名和密码。它使用一个SQLCommand对象对数据库执行一条 SQL 语句。如果找到匹配，它返回雇员的userId.，如果没有找到匹配，它返回-1。因为 SQL 语句返回一个值，所以可以使用SQLCommand对象的ExecuteScalar方法。

将名为DALEmployee的类添加到应用中，并将以下代码插入到类文件中:

using System;
using System.Data.SqlClient;

namespace OfficeSupplyBLL
{
    class DALEmployee
    {
        public int LogIn(string userName, string password)
        {
            string connString = DALUtility.GetSQLConnection("OSConnection");
           using( SqlConnection conn = new SqlConnection(connString))

            {
                using (SqlCommand cmd = new SqlCommand())
                {
                    cmd.Connection = conn;
                    cmd.CommandText = "Select EmployeeID from Employee where "
                         + " UserName = @UserName and Password = @Password ";
                    cmd.Parameters.AddWithValue("@UserName", userName);
                    cmd.Parameters.AddWithValue("@Password", password);
                    int userId;
                    conn.Open();
                    userId = (int)cmd.ExecuteScalar();
                    if (userId > 0)
                    {
                        return userId;
                    }
                    else
                    {
                        return -1;
                    }
                }
            }

        }
    }
}

下一个要构建的类是DALProductCatalog类，其目的是封装应用检索和列出数据库中可用产品所需的功能。您还希望能够根据产品所属的类别来查看产品。您需要的信息在两个数据库表中:目录表和产品表。这两个表通过CatID字段相关联。

当客户端请求产品目录信息时，会创建一个数据集并将其返回给客户端。该服务在DALProductCatalog类的GetProductInfo方法中提供。将名为DALProductCatalog的类添加到项目中，并插入如下所示的代码:

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OfficeSupplyBLL
{
    public class DALProductCatalog
    {
        public DataSet GetProductInfo()
        {
            DataSet _dsProducts;
            string connString = DALUtility.GetSQLConnection("OSConnection");
            using (SqlConnection _conn = new SqlConnection(connString))
           {
                _dsProducts = new DataSet("Products");
                //Get category info
                String strSQL = "Select CategoryId, Name, Description from Category";
                using(SqlCommand cmdSelCategory = new SqlCommand(strSQL, _conn))
                {
                    using(SqlDataAdapter daCatagory = new SqlDataAdapter(cmdSelCategory))
                    {
                        daCatagory.Fill(_dsProducts, "Category");
                    }
                }

                //Get product info
                String strSQL2 = "Select ProductID, CategoryID, Name," +
                    "Description, UnitCost from Product";
                using(SqlCommand cmdSelProduct = new SqlCommand(strSQL2, _conn))
                {
                    using (SqlDataAdapter daProduct = new SqlDataAdapter(cmdSelProduct))
                    {
                        daProduct.Fill(_dsProducts, "Product");
                    }
                }
           }
                //Set up the table relation
                DataRelation drCat_Prod = new DataRelation("drCat_Prod",
                    _dsProducts.Tables["Category"].Columns["CategoryID"],
                    _dsProducts.Tables["Product"].Columns["CategoryID"], false);
                _dsProducts.Relations.Add(drCat_Prod);
            return _dsProducts;
        }
    }
}

当客户端准备提交订单时，它将调用Order类的PlaceOrder方法，稍后您将在业务逻辑类中定义这个类。客户机将雇员 ID 传递给方法，并接收一个订单编号作为返回值。Order类的PlaceOrder方法将以 XML 字符串的形式将订单信息传递给DALOrder类进行处理。DALOrder类包含PlaceOrder方法，该方法从Order类接收 XML 订单字符串，并将其传递给 SQL Server 数据库中的存储过程。存储过程更新数据库并传回订单号。然后，这个订单号被返回给Order类，该类又将订单号传递回客户端。

将名为DALOrder的类添加到项目中，并将以下代码插入到类文件中:

using System;
using System.Data;
using System.Data.SqlClient;

namespace OfficeSupplyBLL
{
    class DALOrder
    {
        public int PlaceOrder(string xmlOrder)
        {
            string connString = DALUtility.GetSQLConnection("OSConnection");
            using (SqlConnection cn = new SqlConnection(connString))
            {
                using (SqlCommand cmd = cn.CreateCommand())
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.CommandText = "up_PlaceOrder";
                    SqlParameter inParameter = new SqlParameter();
                    inParameter.ParameterName = "@xmlOrder";
                    inParameter.Value = xmlOrder;
                    inParameter.DbType = DbType.String;
                    inParameter.Direction = ParameterDirection.Input;
                    cmd.Parameters.Add(inParameter);
                    SqlParameter ReturnParameter = new SqlParameter();
                    ReturnParameter.ParameterName = "@OrderID";
                    ReturnParameter.Direction = ParameterDirection.ReturnValue;
                    cmd.Parameters.Add(ReturnParameter);
                    int intOrderNo;
                    cn.Open();
                    cmd.ExecuteNonQuery();
                    cn.Close();
                    intOrderNo = (int)cmd.Parameters["@OrderID"].Value;
                    return intOrderNo;
                }
            }
        }
    }
}

现在您已经构建了数据访问层类，您已经准备好构建业务逻辑层类集了。

构建 OSO 应用的业务逻辑层

将名为Employee的类添加到项目中。这个类将封装 UI 使用的雇员信息，并将登录请求传递给数据访问层。将以下代码添加到 Employee.cs 文件中:

using System;

namespace OfficeSupplyBLL
{
    public   class Employee
    {
        int _employeeID;

        public int EmployeeID
        {
            get { return _employeeID; }
            set { _employeeID = value; }
        }

        string _loginName;

        public string LoginName
        {
            get { return _loginName; }
            set { _loginName = value; }
        }
        string _password;

        public string Password
        {
            get { return _password; }
            set { _password = value; }
        }

        Boolean _loggedIn = false;

        public Boolean LoggedIn
        {
            get { return _loggedIn; }
        }

        public Boolean LogIn()
        {
            DALEmployee dbEmp = new DALEmployee();
            int empId;
            empId = dbEmp.LogIn(this.LoginName, this.Password);
            if (empId > 0)
            {
                this.EmployeeID = empId;
                this._loggedIn = true;
                return true;
            }
            else
            {
                this._loggedIn = false;
                return false;
            }

        }
    }
}

ProductCatalog类向 UI 提供产品数据集。它从DALProductCatalog类中检索数据集。在将数据集传递给 UI 之前，您可以在数据集上执行任何业务逻辑。向项目中添加一个新的ProductCatalog类文件，并添加以下代码来实现ProductCatalog类。

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OfficeSupplyBLL
{
    public class ProductCatalog
    {
        public DataSet GetProductInfo()
        {
            //perform any business logic befor passing to client.
            // None needed at this time.
            DALProductCatalog prodCatalog = new DALProductCatalog();
            return prodCatalog.GetProductInfo();
        }
    }
}

当用户向订单添加项目时，订单项目信息被封装在一个OrderItem 类中。这个类实现了INotifyPropertyChanged接口。此接口是通知 UI 某个属性已更改所必需的，以便它可以更新绑定到该类的任何控件。它还覆盖了ToString方法，以提供包含商品信息的 XML 字符串。当下订单时，这个字符串将被传递给 DAL。

将OrderItem类添加到项目中，并插入以下代码来实现它。

using System;
using System.ComponentModel;

namespace OfficeSupplyBLL
{
    public class OrderItem : INotifyPropertyChanged
    {

        #region INotifyPropertyChanged Members
        public event PropertyChangedEventHandler PropertyChanged;
        protected void Notify(string propName)
        {
            if (this.PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propName));
            }
        }
        #endregion

        string _ProdID;
        int _Quantity;
        double _UnitPrice;
        double _SubTotal;
        public string ProdID
        {
            get { return _ProdID; }
            set { _ProdID = value; }
        }
        public int Quantity
        {
            get { return _Quantity; }
            set
            {
                _Quantity = value;
                Notify("Quantity");
            }
        }
        public double UnitPrice
        {
            get { return _UnitPrice; }
            set { _UnitPrice = value; }
        }
        public double SubTotal
        {
            get { return _SubTotal; }
        }
        public OrderItem(String productID, double unitPrice, int quantity)
        {
            _ProdID = productID;
            _UnitPrice = unitPrice;
            _Quantity = quantity;
            _SubTotal = _UnitPrice * _Quantity;
        }
        public override string ToString()
        {
            string xml = "<OrderItem";
            xml += " ProductID='" + _ProdID + "'";
            xml += " Quantity='" + _Quantity + "'";
            xml += " />";
            return xml;
        }
    }
}

业务逻辑层的最后一个类是Order类。该类负责维护订单项的集合。它有添加和删除项目的方法，以及在下订单时将项目传递给DALOrder类的方法。

在项目中添加了一个Order类之后，使用下面的代码来实现这个类:

using System;
using System.Collections.ObjectModel;

namespace OfficeSupplyBLL
{
    public class Order
    {

        ObservableCollection<OrderItem> _orderItemList = new
            ObservableCollection<OrderItem>();

        public ObservableCollection<OrderItem> OrderItemList
        {
            get { return _orderItemList; }
        }
        public void AddItem(OrderItem orderItem)
        {
            foreach (var item in _orderItemList)
            {
                if (item.ProdID == orderItem.ProdID)
                {
                    item.Quantity += orderItem.Quantity;

                    return;
                }
            }
            _orderItemList.Add(orderItem);
        }
        public void RemoveItem(string productID)
        {
            foreach (var item in _orderItemList)
            {
                if (item.ProdID == productID)
                {
                    _orderItemList.Remove(item);
                    return;
                }
            }
        }
        public double GetOrderTotal()
        {
            if (_orderItemList.Count == 0)
            {
                return 0.00;
            }
            else
            {
                double total = 0;
                foreach (var item in _orderItemList)
                {
                    total += item.SubTotal;
                }
                return total;
            }
        }
        public int PlaceOrder(int employeeID)
        {
            string xmlOrder;
            xmlOrder = "<Order EmployeeID='" + employeeID.ToString() + "'>";
            foreach (var item in _orderItemList)
            {
                xmlOrder += item.ToString();
            }
            xmlOrder += "</Order>";
            DALOrder dbOrder = new DALOrder();
            return dbOrder.PlaceOrder(xmlOrder);
        }
    }
}

现在，您已经构建了 OSO 应用的数据访问和业务逻辑层，您已经准备好构建用户界面(UI)了。因为您在不同的层中创建了应用，所以您可以选择使用基于 Windows 的 WPF 用户界面、基于 ASP.NET 网络的用户界面或 Windows 应用商店应用。您还可以根据用户用来与应用交互的设备来创建多个 UI。在下一节中，您将构建一个 WPF 应用，用户将使用它从他们的桌面计算机上订购办公用品。

创建 OSO 应用用户界面

为了创建订购系统的 WPF 接口，您需要向包含 OfficeSupplyBLL 项目的解决方案中添加一个 WPF 项目。

在 Visual Studio 中，向解决方案中添加一个 WPF 项目，并将其命名为 OfficeSupplyWPF。项目加载后，添加对 OfficeSupplyBLL 项目的引用，如图图 15-7 所示。

图 15-7 。添加对 OfficeSupplyBLL 项目的引用

在 App.config 文件中，将下面的 xml 代码添加到配置结束标记之前。请记住，根据您的服务器设置，您可能需要更改数据源。

  <connectionStrings>
    <add name="OSConnection"
      providerName="System.Data.SqlClient"
      connectionString="data source=localhost;initial catalog=OfficeSupply;
                       integrated security=True;"/>
  </connectionStrings>

用户界面的第一个目标是展示可以订购的产品信息。产品信息呈现在数据网格控件中。用户将通过选择 ComboBox 控件中的类别来查看特定类别中的产品。产品列出后，用户可以将产品添加到订单中。当一个产品被添加到订单中时，它会显示在数据网格下面的列表视图中。图 15-8 显示了在订单中添加了项目的 OSO 订单。

图 15-8 。向订单添加项目的表单

将以下 XAML 代码添加到 MainWindow.xaml 文件中，以创建 OSO 订单。请注意数据绑定在各种控件中的使用。例如，数据网格的项目来源被设置为类别表和产品表之间的数据关系(ItemsSource="{Binding drCat_Prod}")。这允许数据网格显示下拉列表中所选类别的产品。

<Window x:Class="OfficeSupplyWPF.MainWindow"
        FontName1">http://schemas.microsoft.com/winfx/2006/xaml/presentation "
        xmlns:x=" http://schemas.microsoft.com/winfx/2006/xaml "
        Title="Office Supply Ordering" Height="484" Width="550" Loaded="Window_Loaded">
    <Grid>
        <StackPanel Name="LayoutRoot" DataContext="{Binding}"
                Orientation="Vertical" HorizontalAlignment="Left" Height="auto" Width="auto">
            <StackPanel Orientation="Horizontal" HorizontalAlignment="Left">
                <Label Content="Categories:" Margin="10,0,0,0"/>
                <ComboBox ItemsSource="{Binding}" Name="categoriesComboBox"
                          IsSynchronizedWithCurrentItem="True"
                      DisplayMemberPath="Name" Height="23" Margin="12" Width="200" >
                <ComboBox.ItemsPanel>
                        <ItemsPanelTemplate>
                            <VirtualizingStackPanel />
                        </ItemsPanelTemplate>
                    </ComboBox.ItemsPanel>
                </ComboBox>
                <Button Content="Login" Height="30" Name="loginButton"
                        Width="75" Margin="20,5,0,0" Click="loginButton_Click" />
                <Button Content="Exit" Height="30" Name="exitButton"
                        Width="75" Margin="20,5,0,0" Click="exitButton_Click" />
            </StackPanel>
            <DataGrid AutoGenerateColumns="False" Height="165"
                      ItemsSource="{Binding drCat_Prod}"
                      Name="ProductsDataGrid" RowDetailsVisibilityMode="VisibleWhenSelected"
                      Width="490" HorizontalAlignment="Left" Margin="20,0,20,10"
                      SelectionMode="Single">
                <DataGrid.Columns>
                    <DataGridTextColumn
                    x:Name="productIDColumn" Binding="{Binding Path=ProductID}"
                    Header="Product ID" Width="40*" />
                    <DataGridTextColumn
                    x:Name="nameColumn" Binding="{Binding Path=Name}"
                    Header="Name" Width="40*" />
                    <DataGridTextColumn
                    x:Name="descriptColumn" Binding="{Binding Path=Description}"
                    Header="Description" Width="80*" />
                    <DataGridTextColumn
                    x:Name="unitCostColumn" Binding="{Binding Path=UnitCost}"
                    Header="Unit Cost" Width="30*" />
                </DataGrid.Columns>
            </DataGrid>

            <StackPanel Orientation="Vertical">
                <ListView Name="orderListView" MinHeight="150" Width="490"
                          ItemsSource="{Binding}" SelectionMode="Single">
                    <ListView.View>
                        <GridView>
                            <GridViewColumn Width="140" Header="Product Id"
                                            DisplayMemberBinding="{Binding ProdID}" />
                            <GridViewColumn Width="140" Header="Unit Price"
                                            DisplayMemberBinding="{Binding UnitPrice}" />
                            <GridViewColumn Width="140" Header="Quantity"
                                            DisplayMemberBinding="{Binding Quantity}" />
                        </GridView>
                    </ListView.View>
                </ListView>

            </StackPanel>
            <StackPanel Orientation="Horizontal" HorizontalAlignment="Center">
                <Button Name="addButton" MinHeight="25" MinWidth="80"
                        Content="Add Item" Click="addButton_Click" />
                <Button Name="removeButton" MinHeight="25" MinWidth="80"
                        Content="Remove Item" Click="removeButton_Click"/>
                <Button Name="placeOrderButton" MinHeight="25" MinWidth="80"
                        Content="Place Order" Click="placeOrderButton_Click"/>
            </StackPanel>
        </StackPanel>
        <StatusBar VerticalAlignment="Bottom" HorizontalAlignment="Stretch">
            <TextBlock Name="statusTextBlock">You must log in to place an order.</TextBlock>
        </StatusBar>
    </Grid>
</Window>

要添加订单项，用户首先在数据网格中选择一行，然后选择“添加项”按钮。“添加项目”按钮显示一个对话框，用户可以使用该对话框输入数量并添加项目。图 15-9 显示了订单项目对话框。

图 15-9 。订单项目对话框

向名为 OrderItemDialog.xaml 的项目添加一个新窗口。添加以下 xaml 代码以创建OrderItemDialog表单:

<Window x:Class="OfficeSupplyWPF.OrderItemDialog"
        FontName1">http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                WindowStartupLocation="CenterOwner"
        Title="Order Item" Height="169" Width="300">
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto" />
            <ColumnDefinition Width="Auto" />
            <ColumnDefinition />
        </Grid.ColumnDefinitions>

        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition />
        </Grid.RowDefinitions>
        <Label Grid.Column="0" Grid.Row="0" Margin="2">Product Id:</Label>
        <TextBox Name="productIdTextBox" Grid.Column="1"
                 Grid.Row="0" Margin="2" Grid.ColumnSpan="2" IsEnabled="False"/>
        <Label Grid.Column="0" Grid.Row="1" Margin="2">Unit Price:</Label>
        <TextBox Name="unitPriceTextBox" Grid.Column="1"
                 Grid.Row="1" Margin="2" Grid.ColumnSpan="2" IsEnabled="False"/>
        <Label Grid.Column="0" Grid.Row="2" Margin="2" >Quantity:</Label>
        <TextBox Name="quantityTextBox" Grid.Column="1"
                 Grid.Row="2" Margin="2" MinWidth="80" Text="1"/>
        <StackPanel Grid.Column="0" Grid.ColumnSpan="3"
                    Grid.Row="3" Orientation="Horizontal"
                    HorizontalAlignment="Center">
            <Button Name="okButton" Click="okButton_Click" IsDefault="True"
                    MinWidth="80" Margin="5">OK</Button>
            <Button Name="cancelButton" Click="cancelButton_Click" IsCancel="True"
                    MinWidth="80" Margin="5">Cancel</Button>
        </StackPanel>
    </Grid>
</Window>

用户必须先登录，然后才能提交订单。当他们点击登录按钮时，会出现一个登录对话窗口，如图图 15-10 所示。

图 15-10 。登录对话框

向名为 LoginDialog.xaml 的项目添加一个新窗口。

<Window x:Class="OfficeSupplyWPF.LoginDialog"
        FontName1">http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Login" Height="131" Width="300"
        WindowStartupLocation="CenterOwner"
        FocusManager.FocusedElement="{Binding ElementName=nameTextBox}">
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto" />
            <ColumnDefinition />
        </Grid.ColumnDefinitions>

        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition />
        </Grid.RowDefinitions>
        <Label Grid.Column="0" Grid.Row="0" Margin="2">Name:</Label>
        <TextBox Name="nameTextBox" Grid.Column="1" Grid.Row="0" Margin="2"/>
        <Label Grid.Column="0" Grid.Row="1" Margin="2">Password:</Label>
        <PasswordBox Name="passwordTextBox" Grid.Column="1" Grid.Row="1" Margin="2"/>

        <StackPanel Grid.Column="0" Grid.ColumnSpan="2" Grid.Row="2"
                    Orientation="Horizontal" HorizontalAlignment="Center">
            <Button Name="okButton" Click="okButton_Click" IsDefault="True"
                    MinWidth="80" Margin="5">OK</Button>
            <Button Name="cancelButton" Click="cancelButton_Click" IsCancel="True"
                    MinWidth="80" Margin="5">Cancel</Button>
        </StackPanel>
    </Grid>
</Window>

现在，您已经创建了构成 UI 的窗口，您可以将实现添加到窗口的代码隐藏文件中了。

将以下代码添加到 MainWindow.xaml.cs 代码隐藏文件中。下面是对代码的讨论。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
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.Data;
using OSOBLL;
using System.Collections.ObjectModel;

namespace OfficeSupplyWPF
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {

        DataSet _dsProdCat;
        Employee _employee;
        Order _order;

        public MainWindow()
        {
            InitializeComponent();

        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            ProductCatalog prodCat = new ProductCatalog();
            _dsProdCat = prodCat.GetProductInfo();
            this.DataContext = _dsProdCat.Tables["Category"];
            _order = new  Order();
            _employee = new Employee();
            this.orderListView.ItemsSource = _order.OrderItemList;
        }

        private void loginButton_Click(object sender, RoutedEventArgs e)
        {

            LoginDialog dlg = new LoginDialog();
            dlg.Owner = this;
            dlg.ShowDialog();
            // Process data entered by user if dialog box is accepted
            if (dlg.DialogResult == true)
            {
                _employee.LoginName = dlg.nameTextBox.Text;
                _employee.Password = dlg.passwordTextBox.Password;
                if (_employee.LogIn() == true)
                {
              this.statusTextBlock.Text = "You are logged in as employee number " +
                _employee.EmployeeID.ToString();
                }
                else
                {
                    MessageBox.Show("You could not be verified. Please try again.");
                }
            }
        }

        private void exitButton_Click(object sender, RoutedEventArgs e)
        {
            this.Close();
        }

        private void addButton_Click(object sender, RoutedEventArgs e)
        {

            OrderItemDialog orderItemDialog = new OrderItemDialog();

            DataRowView selectedRow;
            selectedRow = (DataRowView)this.ProductsDataGrid.SelectedItems[0];
            orderItemDialog.productIdTextBox.Text = selectedRow.Row.ItemArray[0].ToString();
            orderItemDialog.unitPriceTextBox.Text = selectedRow.Row.ItemArray[4].ToString();
            orderItemDialog.Owner = this;
            orderItemDialog.ShowDialog();
            if (orderItemDialog.DialogResult == true )
            {
                string productId = orderItemDialog.productIdTextBox.Text;
                double unitPrice = double.Parse(orderItemDialog.unitPriceTextBox.Text);
                int quantity = int.Parse(orderItemDialog.quantityTextBox.Text);
                _order.AddItem(new OrderItem(productId,unitPrice,quantity));
            }
        }

        private void removeButton_Click(object sender, RoutedEventArgs e)
        {
            if (this.orderListView.SelectedItem != null)
            {
                var selectedOrderItem = this.orderListView.SelectedItem as OrderItem;
                _order.RemoveItem(selectedOrderItem.ProdID);
            }
        }

        private void placeOrderButton_Click(object sender, RoutedEventArgs e)
        {
            if (_employee.LoggedIn == true)
            {
                //place order
                int orderId;
               orderId = _order.PlaceOrder(_employee.EmployeeID);
               MessageBox.Show("Your order has been placed. Your order id is " +
                    orderId.ToString());
            }
            else
            {
                MessageBox.Show("You must be logged in to place an order.");
            }
        }
    }
}

看一下前面的代码就会发现，当窗口加载时，Window_Loaded事件检索ProdCat数据集，并将其设置为等于窗口的DataContext，以便 ComboBox 和 GridView 控件可以绑定到它。一个Order对象被创建，ListView 控件被绑定到它的OrderItem集合。

private void Window_Loaded(object sender, RoutedEventArgs e)
{
    ProductCatalog prodCat = new ProductCatalog();
    _dsProdCat = prodCat.GetProductInfo();
    this.DataContext = _dsProdCat.Tables["Category"];
    _order = new  Order();
    _employee = new Employee();
    this.orderListView.ItemsSource = _order.OrderItemList;
 }

loginButton_Click 事件启动 LoginDialog 窗口的一个实例，并检查对话结果。如果返回 true，_employee对象的值被设置为对话框中输入的值，并且调用Employee类的Login方法。如果Login方法返回 true，用户被通知他们已经登录。

  private void loginButton_Click(object sender, RoutedEventArgs e)
  {

      LoginDialog dlg = new LoginDialog();
      dlg.Owner = this;
      dlg.ShowDialog();
      // Process data entered by user if dialog box is accepted
      if (dlg.DialogResult == true)
      {
          _employee.LoginName = dlg.nameTextBox.Text;
          _employee.Password = dlg.passwordTextBox.Password;
          if (_employee.LogIn() == true)
          {
this.statusTextBlock.Text = "You are logged in as employee number " +
          _employee.EmployeeID.ToString();
          }
          else
          {
              MessageBox.Show("You could not be verified. Please try again.");
          }
      }
  }

addButton_Click事件启动 OrderItemDialog 窗口的一个实例，并用 ProductsDataGrid 的选定行中的信息填充文本框。如果DialogResult返回 true，则在对话框中输入的信息用于创建一个OrderItem对象，并将其添加到订单的OrderItem集合中。

private void addButton_Click(object sender, RoutedEventArgs e)
{

    OrderItemDialog orderItemDialog = new OrderItemDialog();

    DataRowView selectedRow;
    selectedRow = (DataRowView)this.ProductsDataGrid.SelectedItems[0];
    orderItemDialog.productIdTextBox.Text = selectedRow.Row.ItemArray[0].ToString();
    orderItemDialog.unitPriceTextBox.Text = selectedRow.Row.ItemArray[4].ToString();
    orderItemDialog.Owner = this;
    orderItemDialog.ShowDialog();
    if (orderItemDialog.DialogResult == true )
    {
        string productId = orderItemDialog.productIdTextBox.Text;
        double unitPrice = double.Parse(orderItemDialog.unitPriceTextBox.Text);
        int quantity = int.Parse(orderItemDialog.quantityTextBox.Text);
        _order.AddItem(new OrderItem(productId,unitPrice,quantity));
    }
}

removeButton_Click事件检查是否在orderListView中选择了一个项目，并将其从订单中删除。

private void removeButton_Click(object sender, RoutedEventArgs e)
{
    if (this.orderListView.SelectedItem != null)
    {
        var selectedOrderItem = this.orderListView.SelectedItem as OrderItem;
        _order.RemoveItem(selectedOrderItem.ProdID);
    }
}

placeOrderButton_Click事件检查用户是否登录，如果登录就下订单。

private void placeOrderButton_Click(object sender, RoutedEventArgs e)
{
    if (_employee.LoggedIn == true)
    {
        //place order
        int orderId;
       orderId = _order.PlaceOrder(_employee.EmployeeID);
       MessageBox.Show("Your order has been placed. Your order id is " + orderId.ToString());
    }
    else
    {
        MessageBox.Show("You must be logged in to place an order.");
    }
}

现在主窗口的代码隐藏已经实现，您可以为对话框窗口添加代码隐藏了。

将以下代码添加到 OrderItemDialog.xaml.cs 代码隐藏文件中。如果用户点击 OK 按钮，则DialogResult被设置为true。如果用户点击取消，则DialogResult被设置为false。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
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 OfficeSupplyWPF
{
    /// <summary>
    /// Interaction logic for OrderItemDialog.xaml
    /// </summary>
    public partial class OrderItemDialog : Window
    {
        public OrderItemDialog()
        {
            InitializeComponent();
        }

        private void okButton_Click(object sender, RoutedEventArgs e)
        {
            this.DialogResult = true;
        }

        private void cancelButton_Click(object sender, RoutedEventArgs e)
        {
            this.DialogResult = false;
        }
    }
}

将以下代码添加到 LoginDialog.xaml.cs 代码隐藏文件中。它类似于 OrderItemDialog 代码。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
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 OfficeSupplyWPF
{
    /// <summary>
    /// Interaction logic for LoginDialog.xaml
    /// </summary>
    public partial class LoginDialog : Window
    {
        public LoginDialog()
        {
            InitializeComponent();
        }

        private void okButton_Click(object sender, RoutedEventArgs e)
        {
            this.DialogResult = true;
        }

        private void cancelButton_Click(object sender, RoutedEventArgs e)
        {
            this.DialogResult = false;
        }
    }
}

现在，您已经将实现代码添加到 UI 中，您已经准备好测试应用了。花点时间玩玩这个应用。向订单中添加一些项目，并测试从订单中删除一些项目。尝试下订单(用户的有效登录是JSmith，密码是js)。当您使用这个应用时，想想您可以做些什么来改进它。需要改进的一个方面是对可能发生的错误进行捕获。例如，如果您单击“添加项目”按钮而没有在网格中选择项目，程序将会崩溃。处理这种情况的一种方法是禁用按钮，除非选择了网格行。

您可能还想扩展应用。例如，您可以实现 Windows 应用商店应用接口。另一个有趣的项目是开发一个接受应用下订单的 web 服务。

注意虽然这是一个功能应用，但它仅用于演示目的，还没有准备好投入生产。

摘要

在这一章中，你回顾了在第四章中设计的办公用品订购(OSO)应用。您创建了一个功能性应用，其中包含了您在前面章节中学到的概念。该应用包含数据访问层、业务逻辑层和用户界面层。您了解了为什么应用被分成不同的层，以及如何构建由不同层组成的工作应用。虽然您没有创建基于 web 的用户界面应用层，但因为您在不同的层中创建了应用，所以您可以轻松地将基于 Windows 的 WPF UI 替换为基于 web 的 UI 或 Windows 应用商店应用。您还使用 ADO.NET 创建了数据访问层。另一种选择是使用实体框架(EF)。您还可以创建一个 web 服务来将订单发送给供应商。

十六、总结

如果你已经走了这么远，花点时间拍拍自己的背。自从你第一次打开这本书的封面以来，你已经走过了漫长的道路；您已经获得了宝贵的技能和概念，您可以使用 .NET 框架、C# 和 Visual Studio IDE。这些包括但不限于以下内容:

• 应用设计周期的重要性
• 统一建模语言(UML)以及它如何帮助促进面向对象程序的分析和设计
• 公共语言运行时(CLR)
• 的结构 .NET 框架
• 如何创建和使用类结构和层次结构
• 如何实现继承、多态和接口
• 对象交互和协作
• 事件驱动编程
• 结构化错误处理
• 如何使用 ADO.NET 处理数据结构和数据源
• 使用实体框架创建到 SQL Server 数据库的对象关系映射
• 如何使用 Visual Studio IDE 的功能来提高生产率和简化调试
• 如何使用 Windows 演示框架实现基于 Windows 的图形用户界面
• 如何使用 ASP.NET 和 web 窗体实现基于 Web 的图形用户界面
• 如何创建 Windows 应用商店应用
• 如何使用 Windows Communication Foundation 和 ASP.NET Web API 创建和使用服务

恭喜你！你现在可以称自己为 C# 程序员(尽管是个新手)。但是，不要把自己看得太高。如果你的目标是成为一名专业 C# 程序员，你的旅程才刚刚开始。你发展的下一个阶段是积累经验。换句话说，设计和编码，然后再设计和编码。如果你在工作中设计和编写 C# 代码，这将会很容易。(尽管在他们送你去上了三天的课程后，如果你被期望成为一名专家，这将会很有压力！)

如果你是自学，你必须找到时间和项目来学习。这比你想象的要简单。每天花一个小时，想出一个计划的点子。例如，您可以设计一个程序，将菜谱转换成可扩展标记语言(XML)数据。然后，XML 数据可以生成购物清单。见鬼，如果你真的想全力以赴，那就加入一个库存追踪系统，追踪你库存中的配料。无论你如何获得经验，记住这条重要的格言:要么使用它，要么失去它！

以下部分强调了在开发编程技能时需要考虑的一些其他重要事项。

提高您的面向对象设计技能

面向对象的分析和设计是你作为程序员要完成的两项最困难的任务。这些技能对大多数程序员来说并不容易。然而，它们是你应该努力掌握的两项最重要的技能。他们就是我所说的程序员和程序员的区别。如果你和大多数首席信息官和编程经理交谈，找到编码员很容易；他们要的是程序员。**

**记住，没有一种“正确”的方法，而是几种同样有效的方法。

调查 .NET Framework 命名空间

那个 .NET Framework 包含大量的类、接口和其他类型，旨在优化和加快您的开发工作。组成的各种命名空间 .NET Framework 类库是按功能组织的。花时间熟悉这些名称空间提供的功能很重要。

从包含您最常使用的功能的名称空间开始，比如根名称空间System和System.IO，其中包含。用于读写流和文件的. NET Framework 类。

在熟悉了更常见的名称空间之后，探索一些更难理解的名称空间。例如，System.Security.Cryptography提供数据编码、哈希、消息认证等密码服务。您将会惊讶于该框架所提供的支持范围。您可以在 Visual Studio 的集成文档中找到有关各种命名空间成员的大量信息。

熟悉 ADO.NET 和实体框架

数据是编程的基础。你在你写的每个程序中存储、检索和操作数据。程序在执行过程中使用的数据结构是非持久数据——它保存在 ram 中。当应用终止时，这些数据会丢失，并且必须在下次应用运行时重新创建。持久数据是保存在永久数据结构中的数据，如文件系统或数据库。大多数程序需要从某种持久的数据存储中检索数据，并将数据持久存储到其中。这就是 ADO.NET 介入的地方。ADO.NET 是指包含处理持久数据的功能的名称空间。(它还包含在熟悉的关系数据库或 XML 类型的结构中组织和处理非持久数据的功能。)虽然我已经向您介绍了 ADO.NET 和实体框架，但这是一个非常重要的主题，值得专门写一本书来介绍这些数据访问技术。(别担心——有很多！)这绝对是一个你需要投入进一步研究的领域。要了解有关这些技术的更多信息，请访问数据开发人员中心网站http://msdn.microsoft.com/en-us/data。

了解有关创建优秀用户界面(UI)的更多信息

尽管我向你介绍了 ASP.NET 的 WPF 和 Windows 应用商店，但我只是触及了这些强大技术的皮毛。ASP.NET WPF 和 Windows 应用商店的应用包含了丰富的功能，可以在 web、桌面和移动设备上开发引人入胜的交互式用户体验。有关 WPF 编程的更多信息，请访问位于http://windowsclient.net的 Windows 客户端开发中心。欲了解更多关于 ASP.NET 编程的信息，请访问位于http://www.asp.net的开发者中心。如果您对 Windows Store 应用开发感兴趣，请访问位于http://msdn.microsoft.com/en-US/windows/apps/br229512的开发者中心。这些网站充满了学习材料和展示这些技术威力的演示应用。

转向基于组件的开发

在你掌握了面向对象的开发和你的编程逻辑在类系统中的封装之后，你就可以向基于组件的开发迈进了。组件是进一步封装编程逻辑功能的集合。尽管 OSO 应用的业务逻辑层与数据访问层在逻辑上是隔离的，但实际上它们位于同一个程序集中。通过将每个编译成自己的程序集，可以增加代码的维护和重用。您应该开始转向乐高式的应用开发方法。在这种情况下，您的应用由一组独立的部分(程序集)组成，这些部分可以连接在一起，协同工作以执行必要的服务。关于这个和其他最佳实践的更多信息，请访问微软的模式和实践网站http://pnp.azurewebsites.net/en-us/ .

查找帮助

上有大量的信息 .NET 框架和 C# 编程语言。Visual Studio 提供的帮助系统对于程序员来说是一个极好的资源。养成虔诚地使用这种资源的习惯。

另一个极其重要的资源是http://msdn.microsoft.com。该网站由 Microsoft 为开发人员提供，包含大量信息，包括白皮书、教程和网络广播研讨会；老实说，这是业内信息量最大的网站之一。如果您正在使用 Microsoft 技术开发您的编程技能，那么访问这个站点应该像阅读日报一样成为一种常规。也有一些独立的网站致力于各种 .NET 编程语言。一个很好的网站是 C# Corner ( http://www.c-sharpcorner.com/)，它包含了大量关于 C# 编程各个方面的文章。您可以使用您最喜欢的搜索引擎来发现 Web 上其他致力于 C# 编程的好站点。

加入用户组

微软为本地的发展提供了大量的支持。网络用户群。用户组由对以下感兴趣的成员组成 .NET 编程。这些小组为学习、指导和建立关系网提供了很好的途径。有一个列表。在http://msdn.microsoft.com可用的网络用户组。国际 .NET 协会(INETA)也为。网络用户群体；您可以在http://www.ineta.org找到 INETA 附属用户组的列表。

如果你在你所在的地区找不到. NET 用户组，见鬼，为什么不创建一个呢？

请提供反馈

虽然已经尽了一切努力为您提供一个没有错误的文本，但在编辑过程中还是不可避免地会出现一些错误。我致力于在 Apress 网站(http://www.apress.com)上提供更新的勘误表，但是没有你的帮助我无法做到。如果你在阅读这篇文章时遇到任何错误，请通过新闻网站向我报告。

谢谢你，祝你好运！

我真诚地希望你发现阅读这篇文章是一次愉快而有价值的经历。我想感谢你让我成为你这次旅程的向导。正如你作为开发人员的技能会因为阅读这本书而提高一样，我作为开发人员的技能也会因为写这本书而大大提高。我在过去 20 年的教学和培训经验告诉我，只有当你能把一门课程教给别人时，你才能真正理解这门课程。所以，再次感谢你，祝你好运！**

十七、附录一：基本编程概念

以下信息是为编程新手和需要一些基本编程概念入门的读者准备的。如果您已经用另一种语言编程，那么本附录中的概念对您来说可能并不陌生。但是，您应该简要地回顾一下这些资料，以便熟悉 C# 语法。

使用变量和数据类型

编程语言中的变量存储的值可以在程序执行时改变。例如，如果您想计算用户尝试登录应用的次数，您可以使用一个变量来跟踪尝试次数。变量是存储值的内存位置。使用该变量，您的程序可以读取或更改存储在内存中的值。但是，在程序中使用变量之前，必须声明它。当你声明一个变量时，编译器也需要知道什么样的数据将被存储在内存位置。比如会是数字还是字母？如果变量将存储数字，那么一个数字可以有多大？变量是存储小数还是只存储整数？您可以通过给变量分配一个 数据类型来回答这些问题。例如，登录计数器只需要保存正整数。下面的代码演示了如何在 C# 中用整数数据类型声明名为counter的变量:

int counter;

指定数据类型被称为 强类型。强类型导致更有效的内存管理、更快的执行和编译器类型检查，所有这些都减少了运行时错误。运行时错误是程序运行时可能发生的错误，在您构建应用时，编译器不会捕捉到这些错误。例如，由于在计算中使用了错误的数据类型，可能会出现不正确的舍入。

一旦声明了变量，就需要在单独的语句中或者在声明语句本身中给它赋一个初始值。例如，下面的代码:

int counter = 1;

相当于这样:

int counter;
counter = 1;

了解基本数据类型

C# 支持基本数据类型，如数字、字符和日期类型。

整数数据类型

整数数据类型仅表示整数。表 A-1 总结了 C# 中使用的整型数据类型。

表 A-1 整数数据类型

数据类型	存储大小	取值范围
Byte	8 位	0 到 255
Short	16 位	–32768 到 32767
Integer	32 位	–2147483648 至 2147483647
Long	64 位	-9，223，372，036，854，775，808 至 9，223，372，036，854，775，807

显然，在为变量选择数据类型时，内存大小很重要。一个不太明显的考虑是编译器处理数据类型的容易程度。编译器对整数 执行算术运算比其他类型更有效。通常，最好使用整数作为计数器变量，即使一个字节 或短类型可以轻松管理达到的最大值。

非整数数据类型

如果变量将存储包含小数部分 的数字，那么您必须使用非整数数据类型。C# 支持表 A-2 中列出的非整数数据类型。

表 A-2。非整数数据类型

数据类型	存储大小	取值范围
Single	32 位	负值为–3.4028235 e+38 到–1.401298 e–45；正值为 1.401298 e–45 到 3.4028235E+38
Double	64 位	1.79769313486231570E+308 到–4.94065645841246544 e–324 为负值；正值为 4.94065645841246544 e–324 到 1.79769313486231570E+308
Decimal	128 位	0 到+/-79，228，162，514，264，337，593，543，950，335，不带小数点；0 到+/-7.9228162514264337593543950335，小数点右边有 28 位

与单个 或双 数据类型相比，十进制数据类型包含更多的有效数字，并且不受舍入误差的影响。十进制数据类型通常用于需要更高精度的金融或科学计算。

字符数据类型

字符数据类型用于保存人类语言中使用的字符的变量。例如，字符数据类型保存字母(如“a”)或用于显示和打印的数字(如“2 个苹果”)C# 中的字符数据类型是基于 Unicode 的，Unicode 定义了一个字符集，可以表示从英语到阿拉伯语和中文普通话等各种语言中的字符。C# 支持两种字符数据类型:char和string。char数据类型保存单个(16 位)Unicode 字符值，如a或B。字符串数据类型包含一系列 Unicode 字符。它的范围从 0 到大约 20 亿个字符。

布尔数据类型

布尔数据类型包含一个 16 位值，该值被解释为 true 或 false。它用于只能是两个值之一的变量，例如是或否，或开或关。

日期数据类型

日期以 64 位整数保存，其中每个增量代表从公历开始(1/1/0001 12:00a.m)经过的一段时间。).

对象数据类型

object 数据类型是一个 32 位地址，指向另一种数据类型的内存位置。当变量引用的实际数据类型直到运行时才能确定时，通常使用它来声明变量。尽管 object 数据类型可以是引用其他数据类型的总称，但就性能而言，它是最低效的数据类型，除非绝对必要，否则应该避免使用。

可空的 类型

默认情况下，不能为布尔值、整数和 double 数据类型等值类型分配空值。当从数据结构中检索数据时，比如一个允许空值的数据库，这可能会成为问题。当声明一个可能被赋值为 null 的值类型变量时，通过将问号(？)在类型名之后，像这样:

double salary = null; // Not allowed.
double? salary = null; // allowed.

介绍复合 数据类型

组合基本数据类型可以创建复合数据类型。结构、数组和类是复合数据类型的例子。

构筑物

当您想要组织和处理不需要类方法和构造函数开销的信息时，结构数据类型非常有用。它非常适合表示轻量级对象，如点或矩形的坐标。structure 类型的单个变量可以存储这样的信息。你用关键字struct声明一个结构。例如，下面的代码创建了一个名为Point的结构来存储二维表面中点的坐标:

public struct Point
{
  public int _x, _y;

  public Point(int x, int y)
  {
  _x = x;
  _y = y;
  }
}

一旦定义了结构，就可以声明结构类型的变量并创建该类型的新实例，如下所示:

Point p1 = new Point(10,20);

数组

数组通常用于组织和处理相同数据类型的组；例如，您可能需要处理一组名称，因此您可以通过在变量名后紧跟方括号([])来声明数组数据类型，如下所示:

string[] name;

new操作符用于创建数组，并将其元素初始化为默认值。因为数组的元素由从零开始的索引引用，所以下面的数组包含五个元素:

string[] name = new string[4];

要在声明数组时初始化数组元素，可以使用花括号({})列出值。因为可以推断出数组的大小，所以不必声明它。

string[] name = {"Bob","Bill","Jane","Judy"};

C# 支持多维数组。声明数组时，用逗号分隔维度的大小。以下声明创建一个五行四列的二维整数数组:

string[,] name = new string[4,3];

要在声明二维数组时初始化该数组的元素，可以在花括号中使用花括号来列出数组元素。

int[,] intArray = {{1,2}, {3,4}, {5,6}, {7,8}};

您可以使用数组名称后跟括号中元素的索引来访问数组元素。第一个元素的索引编号从 0 开始。例如，name[2]引用先前声明的 names 数组的第三个元素，其值为Jane。

类类类

在面向对象的编程语言中，类被广泛使用。本书的大部分内容是关于它们的创建和使用。至此，可以说类为对象定义了一个复杂的数据类型。它们包含关于对象应该如何行为的信息，包括其名称、方法、属性和事件。那个 .NET Framework 包含许多您可以使用的预定义类。您也可以创建自己的类类型定义。定义为类类型的变量包含一个指向对象内存位置的地址指针。下面的代码声明了在 .NET 框架:

StringBuilder sb = new StringBuilder();

查看文字、常量和枚举

尽管变量值在程序执行过程中会发生变化，但文字和常量包含不变的数据项。

文字

文字是隐式分配了数据类型的固定值，通常用于初始化变量。以下代码使用文字将2的值与整数值相加:

Count = Count + 2;

通过检查文本，编译器将数据类型分配给文本。没有十进制值的数值被指定为整数数据类型；具有十进制值的数据被指定为双精度数据类型。关键字true和false被指定为布尔数据类型。如果文字包含在引号中，则它被指定为字符串数据类型。在下面的代码行中，两个字符串文字被组合并赋给一个字符串变量:

FullName = "Bob" + "Smith";

通过向文本追加一个类型字符，可以覆盖文本的默认数据类型赋值。例如，12.25的值将被分配双精度数据类型，而12.25f的值将导致编译器为其分配单数据类型。

常数

很多时候，您必须在代码中重复使用同一个常量值。例如，一系列几何计算可能需要使用圆周率的值。不用在你的代码中重复文字 3.14，你可以通过使用一个声明的常量来使你的代码更可读和可维护。使用关键字const声明一个常量，后跟数据类型和常量名称:

const Single pi = 3.14159265358979323846;

常量在声明时被赋值，这个值不能被修改或重新赋值。

枚举

您经常需要将变量值赋给几个相关的预定义常量之一。在这些情况下，您可以创建枚举类型来对值进行分组。枚举将一组整数常量与可在代码中使用的名称相关联。例如，下面的代码创建了一个类型为Manager的enum，用于定义三个相关的管理器常量，它们的名称分别为DeptManager、GeneralManager和AssistantManager，值分别为0、1和2:

 enum Manager
 {
  DeptManager,
  GeneralManager,
  AssistantManager,
 }

可以声明一个enum类型的变量，并将其设置为一个enum常量。

Manager managerLevel = Manager.DeptManager;

注此 .NET Framework 提供了各种内部常数和枚举，旨在使您的编码更加直观和易读。例如，StringAlignment枚举指定文本字符串相对于其布局矩形的对齐方式。

探索变量范围

变量的两个重要方面是它的范围和生存期。变量的作用域指的是如何从其他代码中访问该变量。变量的生存期是变量有效并可供使用的时间段。变量的作用域和生存期由声明变量的位置和用于声明变量的访问修饰符决定。

块级范围

代码块是一组分组的代码语句。代码块的例子包括以if - else、do - loop或for - next语句组织的代码。块级范围是变量可以拥有的最窄范围。在代码块中声明的变量只能在声明它的代码块中使用。在下面的代码中，变量blockCount只能从 if 块内部访问。任何访问块外变量的尝试都会产生编译器错误。

if (icount > 10)
{
  int blockCount;
  blockCount = icount;
}

程序范围

过程是可以从其他代码中调用和执行的代码块。C# 支持两种类型的过程:方法和属性。在代码块外但在过程内声明的变量具有过程级范围。具有过程范围的变量可以由同一过程中的代码访问。在下面的代码中，计数器iCount是用过程范围声明的，可以从Counter方法的过程块中的任何地方引用:

void Counter()
{
  int iCount = 0;
  do
  {
  iCount = iCount + 2;
  }
  while (iCount < 10);
}

过程范围变量的生存期限于过程执行的持续时间。

模块范围

具有模块范围的变量可用于类或结构中的任何代码。为了具有模块范围，变量在类或结构的一般声明部分(在任何过程块之外)声明。为了限制声明它的模块的可访问性，可以使用private访问修饰符关键字。在下面的代码中，iCount变量可以被类中定义的两个过程访问:

public class Class1
{
  private int _iCount;
  public void IncrementCount()
  {
  int iCount = 0;
  do
  {
  iCount = iCount + 2;
  }
  while (iCount < 10);
  }
  public void ReadCount()
  {
  Console.WriteLine(_iCount.ToString());
  }
}

用模块范围声明的变量的生存期与声明该变量的类或结构的对象实例的生存期相同。

注关于范围的进一步讨论，见第六章。

了解数据类型转换

在程序执行过程中，很多时候都必须将一个值从一种数据类型转换为另一种数据类型。数据类型之间的转换过程称为转换或转换。

隐式转换

C# 编译器会自动为您执行一些数据类型转换。对于数值类型，当要存储的值可以放入变量而不被截断或舍入时，可以进行隐式转换。例如，在下面的代码中，整数数据类型被隐式转换为 long 数据类型:

int i1 = 373737373;
long l1 = i1;
l1 *= l1;

显式转换

显式转换被称为强制转换。若要执行强制转换，请在要转换的值或变量前面的括号中指定要强制转换的类型。以下代码使用强制转换将 double 类型n1显式转换为 integer 类型:

double n1 = 3.73737373;
int i1 = (int)n1;

扩大和缩小转换

当要转换的数据类型可以容纳原始数据类型中包含的所有可能值时，就会发生扩大转换 。例如，整数数据类型可以转换为双精度数据类型，而不会有任何数据丢失或溢出。当数字被截断时，就会发生数据丢失。例如，如果将 2.54 转换为整数数据类型，它将被截断为 2。当数字太大而不适合新的数据类型时，就会发生溢出。例如，如果将数字 50000 转换为 short 数据类型，则超出了 short 数据类型的最大容量，从而导致溢出错误。另一方面，收缩转换 发生在被转换的数据类型不能容纳原始数据类型中可以包含的所有值时。例如，当 double 数据类型的值转换为 short 数据类型时，原始值中包含的任何十进制值都将丢失。此外，如果原始值超过短数据类型的限制，将会发生运行时异常。在代码中实现收缩转换时，应该特别小心地捕捉这些情况。

使用运算符

运算符是一个代码符号，它告诉编译器对一个值执行运算。运算可以是算术、比较或逻辑。

算术运算符

算术运算符对数值类型执行数学操作。表 A-3 列出了 C# 中常用的算术运算符。

表 A-3。算术运算符

操作员	描述
=	分配
*	增加
/	分开
+	添加
-	减法

下面的代码将整数数据类型的值递增 1:

Count = Count + 1;

C# 还支持将赋值和操作结合起来的速记赋值操作符。以下代码等效于前面的代码:

Count += 1;

如果你要增加 1，你也可以使用简写赋值++。以下代码等效于前面的代码:

Count ++;

比较运算符

比较运算符比较两个值，并返回布尔值true或false。表 A-4 列出了 C# 中常用的比较运算符。

表 A-4。比较运算符

操作员	描述
<	不到
<=	小于或等于
>	大于
>=	大于或等于
==	等于
!=	不等于

您可以在条件语句中使用比较运算符来决定何时执行代码块。在显示消息之前，下面的if块检查无效登录尝试的次数是否大于三次:

if (_loginAttempts > 3)
{
  Messagebox.Show("Invalid login.");
}

逻辑运算符

逻辑运算符组合条件运算符的结果。三种最常用的逻辑运算符是 AND、OR 和 NOT 运算符。 AND 运算符(&&)组合两个表达式，如果两个表达式都为真，则返回true。 OR 运算符(||)组合两个表达式，如果其中一个为真，则返回true。 NOT 运算符(!)切换比较结果:值true返回false，值false返回true。以下代码在运行方法之前检查登录用户是部门经理还是助理经理:

if (currentUserLevel == Manager.AssistantManager ||
  currentUserLevel == Manager.DeptManager)
{
  ReadLog();
}

三进制运算符

三元运算符计算布尔表达式，并根据表达式的结果返回两个值之一。下面显示了三元运算符的语法:

condition ? first_expression : second_expression;

如果条件评估为 true，则返回第一个表达式的结果。如果条件评估为 false，则返回第二个表达式的结果。下面的代码检查 x 的值是否为零。如果是，则返回 0；如果不是，它将 y 除以 x 并返回结果。

return x == 0.0 ? 0 : y/x;

介绍决策结构

决策结构允许根据条件语句的评估有条件地执行代码块。if语句评估一个布尔表达式，如果结果为真，则执行代码块。switch语句检查同一个表达式的几个不同值，并根据结果有条件地执行一个代码块。

如果语句

若要在条件为真时执行代码块，请使用以下结构:

if (condition1)
{
  //code
}

若要在条件为真时执行代码块，在条件为假时执行替代代码块，请添加一个 else 块。

if (condition1)
{
  //code
}
else
{
  //code
}

如果第一个评估为false，要测试附加条件，添加一个else - if模块:

if (condition1)
{
  //code
}
else if (condition2)
{
  //code
}
else
{
  //code
}

一条if语句可以有多个-else-if块。如果条件评估为true，则执行相应的代码语句，之后执行跳转到语句的末尾。如果条件评估为false，则检查下一个 else-if 条件。else 块是可选的，但是如果包含，它必须是最后一个。else模块没有条件检查，仅当所有其他条件检查评估为false时才执行。下面的代码演示了如何使用if语句来评估一系列条件。它检查绩效评级以确定使用何种奖金，并检查员工是否是经理以确定最低奖金。

if (performance ==1)
{
  bonus = salary * 0.1;
}
else if (performance == 2)
{
  bonus = salary * 0.08;
}
else if (employeeLevel == Manager.DeptManager)
{
  bonus = salary * 0.05;
}
else
{
  bonus = salary * 0.03;
}

切换报表

虽然switch语句类似于if - else语句，但它用于测试一系列值的单个表达式。switch语句的结构如下:

switch (expression)
{
case 1:
  Console.WriteLine("Case 1");
  break;
case 2:
  Console.WriteLine("Case 2");
  break;
default:
  Console.WriteLine("Default case");
  break;
}

一个switch语句可以有多个case块。如果测试表达式的值与case表达式匹配，那么case块中的代码语句就会执行。在case块执行之后，您需要一个break语句来绕过其余的 case 语句。如果测试表达式与case表达式不匹配，执行跳转到下一个case块。default块没有表达式。如果没有执行其他 case 块，它就会执行。default块是可选的，但如果使用，它必须是最后一个。以下示例使用switch来评估绩效评级，以设置适当的奖金率:

switch(performance)
{
  case 1:
  bonus = salary * 0.1;
  break;
  case 2:
  bonus = salary * 0.08;
  break;
  case 3:
  bonus = salary * 0.03;
  break;
  default:
  bonus = salary * 0.01;
  break;
 }

使用循环结构

循环结构重复一段代码，直到满足一个条件。C# 支持以下循环结构。

而声明

当布尔表达式保持不变时，while语句重复执行代码。表达式在循环开始时计算。下面的代码执行，直到一个有效的登录变量评估为true:

while (validLogin == false)
{
  //code statements...
}

Do-While 语句

do - while循环类似于while循环，只是表达式是在循环结束时计算的。以下代码将循环运行，直到达到最大登录尝试次数:

do
{
  //code statements...
}
while (iCount < maxLoginAttempts);

对于声明

一条for语句根据存储在计数器中的值在一个代码块中循环特定的次数。当您知道循环在设计时需要执行的次数时，For 语句是更好的选择。在for语句后面的括号中，初始化一个计数器，定义求值表达式，并定义计数器的增量。

for (int i = 0; i < 10; i++)
{
  //Code statements...
}

对于每一个语句

for - each语句循环遍历集合中每一项的代码。一个集合 是一组有序的条目；例如，放置在 Windows 窗体上的控件被组织到一个控件集合中。要使用for - each语句，首先声明集合中包含的条目类型的变量。此变量设置为集合中的当前项。下面的for - each语句遍历雇员列表集合中的雇员:

foreach (Employee e in employeeList)
{
  //Code statements
}

如果需要有条件地退出循环代码块，可以使用break语句。下面的代码显示了如何跳出for - each循环:

foreach (Employee e in employeeList)
{
  //Code statements
  if (e.Name == "Bob")
  {
  break;
  }
}

介绍方法

方法是可以从其他代码中调用和执行的代码块。将应用分解成离散的逻辑代码块极大地增强了代码的维护和重用。C# 支持返回值的方法和不返回值的方法。当您声明一个方法时，您为该方法指定一个访问修饰符、一个返回类型和一个名称。下面的代码声明了一个没有返回类型(由关键字指定)的方法，用于记录事件日志的登录:

public void RecordLogin(string userName)
{
  EventLog appLog = new EventLog();
  appLog.Source = "OSO App";
  appLog.WriteEntry(userName + " has logged in.");
}

您可以使用参数列表来声明方法，该列表定义了调用方法时必须传递给该方法的参数。以下代码定义了一个封装奖金分配的方法。调用代码将一个整数类型的值传递给该方法，并接收一个double类型的值。

public double GetBonusRate(int performanceRating)
{
  double bonusRate;
  switch (performanceRating)
  {
  case 1:
  bonusRate = 0.1;
  break;
  case 2:
  bonusRate = 0.08;
  break;
  case 3:
  bonusRate = 0.03;
  break;
  default:
  bonusRate = 0.01;
  break;
  }
  return bonusRate;
  }

下面的代码演示了如何调用方法:

double salary;
int performance = 0;
double bonus = 0;
// Get salary and performance data from data base...
bonus = GetBonusRate(performance) * salary;

如果该方法的访问修饰符是私有的，则只能从同一类中的代码访问它。如果该方法需要被其他类中的代码访问，那么使用public访问修饰符。

本附录中的信息旨在帮助您快速了解一些基本的编程概念。您现在应该更熟悉 C# 语法，并准备通过阅读本书的其余部分来扩展和构建这些概念。

十八、附录二：C# 中的异常处理

这里讨论的主题扩展了在第八章中发现的异常处理的讨论，所以这个讨论假设你已经彻底地回顾了第八章中的。本附录的目的是回顾微软关于异常管理的建议，并介绍 .NET 框架。

管理异常

当违反了您的编程逻辑所做的隐式假设时，就会生成异常。例如，当一个程序试图连接到一个数据库时，它假定数据库服务器已经启动并正在网络上运行。如果找不到服务器，就会产生一个异常。应用优雅地处理任何可能发生的异常是很重要的。如果没有处理异常，您的应用将会终止。

你应该在你的方法中加入一个系统的异常处理过程。为了方便这一过程 .NET 框架通过try、catch和finally代码块利用结构化异常处理。第一步是检测代码执行时可能引发的任何异常。要检测任何抛出的异常，将代码放在 try块中。当在try块中抛出异常时，执行转移到catch块。您可以使用多个catch块来过滤可能抛出的特定类型的异常。 finally块执行您希望执行的任何清理代码。无论是否抛出异常，finally块中的代码都会执行。下面的代码演示如何使用适当的异常处理结构从文件中读取名称列表:

public ArrayList GetNames(string file)
{

    try
    {
        using( StreamReader stream = new StreamReader())
        {
            ArrayList names = new ArrayList();

            while (stream.Peek() > -1)
            {
                names.Add(stream.ReadLine());
            }
        }
    }
    catch (FileNotFoundException e)
    {
        //Could not find file
    }
    catch (FileLoadException e)
    {
        //Could not open file
    }
    catch (Exception e)
    {
        //Some kind of error occurred. Report error.
    }
     finally
    {
        stream.Close();
    }
    return names;
}

捕捉到异常后，流程的下一步是确定如何对其做出响应。您基本上有两种选择:要么从异常中恢复，要么将异常传递给调用过程。以下代码演示了如何通过将结果设置为零来从 DivideByZeroException中恢复:

... 
try
{
  Z = x / y;
}
catch (DivideByZeroException e)
{
  Z = 0;
}
... 

使用 throw语句将异常传递给调用过程。下面的代码演示如何将异常引发到调用过程，在调用过程中可以捕获和处理该异常:

catch (FileNotFoundException e)
{
  throw e;
}

随着异常沿着调用链向上抛出，原始异常的相关性会变得不那么明显。为了保持相关性，您可以将异常包装在一个新的异常中，该异常包含增加异常相关性的附加信息。下面的代码演示如何将捕获的异常包装在新的异常中，然后沿调用链向上传递它:

catch (FileLoadException e)
{
    throw new Exception("GetNames function could not open file", e);
}

您通过使用Exception类的InnerException属性 来保留原始异常。

catch (FileLoadException e)
{
    throw new Exception("Could not open file. " + e.InnerException, e);
}

在应用的各种方法中一致地实现这种异常管理策略，将极大地增强您构建高度可维护、灵活和成功的应用的能力。

使用 .NET 框架异常类

公共语言运行时(CLR) 有一组内置的异常类。如果在执行代码指令时发生错误，CLR 将引发适当异常类型的对象实例。全部 .NET Framework 异常类派生自SystemException类，而后者又派生自Exception类。这些基类提供了所有异常类所需的功能。

框架中的每个名称空间都包含一组从SystemException类派生的异常类。这些异常类处理在实现命名空间中包含的功能时可能发生的常见异常。为了实现健壮的异常处理，熟悉各种名称空间提供的异常类非常重要。例如，表 B-1 总结了System.IO名称空间中的异常类。

表 B-1。System.IO名称空间中的异常类

例外	描述
IOException	使用流、文件和目录访问信息时引发的异常的基类。
DirectoryNotFoundException	当文件或目录的一部分找不到时抛出。
EndOfStreamException	当试图读取超过流的结尾时抛出。
FileLoadException	当找到文件但无法加载时抛出。
FileNotFoundException	当试图访问磁盘上不存在的文件失败时抛出。
PathTooLongException	当路径或文件名超过系统定义的最大长度时抛出。

中的每个异常类 .NET Framework 包含表 B-2 中列出的属性。这些属性有助于识别异常发生的位置及其原因。

表 B-2。异常类属性

属性	描述
Message	获取描述当前异常的消息。
Source	获取或设置导致错误的应用或对象的名称。
StackTrace	获取引发当前异常时调用堆栈上帧的字符串表示形式。
InnerException	获取导致当前异常的异常实例。
HelpLink	获取或设置与此异常关联的帮助文件的链接。

此外，异常类的 ToString方法提供了当前异常的摘要信息。它结合了抛出当前异常的类的名称、消息、调用内部异常的ToString方法的结果以及当前异常的堆栈跟踪信息。

您会发现 .NET Framework 为您提供了处理应用中可能出现的大多数异常的能力。在需要实现自定义错误处理的情况下，可以创建自己的异常类。这些类需要从System.ApplicationException继承，而后者又从System.Exception继承。创建自定义异常类是一个高级主题，因此超出了本文的范围；有关更多信息，请参考。位于http://msdn.microsoft.com/en-us/library/的. NET 框架文档。

使用的重要性

当您编写应用时，很多时候您必须从 C# 托管类型访问非托管资源。例如，您可能需要读写一个文本文件，或者打开一个到数据库的连接。在使用完这些资源后，尽快释放它们是很重要的。如果您等待垃圾收集器来清理资源，它们可能会长时间不可访问，从而阻止其他程序访问这些资源。发生这种情况的一个场景是连接到数据库。可以建立的连接数量有限。如果这些连接没有得到正确的管理，那么性能将会受到很大的影响。

为了安全地释放任何非托管资源，访问这些资源的类必须实现IDispose接口和Dispose方法。向该类的用户保证，调用Dispose方法将正确清理资源。例如，当您完成一个数据库连接时，您应该在一个finally块中调用它的Dispose方法，如下面的代码所示。

SqlConnection pubConnection = new SqlConnection();
string connString;
try
{
    connString = "Data Source=drcsrv01;Initial Catalog=pubs;Integrated Security=True";
    pubConnection.ConnectionString = connString;
    pubConnection.Open();
    //work with data
}
catch (SqlException ex)
{
    throw ex;
}
finally
{
        pubConnection.Dispose();
}

这种模式对于编写可靠的代码非常重要，以至于微软实现了一种方便的语法来确保正确使用IDisposable对象。当您使用using语句时，您要确保当对象超出范围或者当您调用对象的方法时发生异常时，正确地调用了Dispose方法。下面的代码等同于前面显示的用于创建和使用SqlConnection的代码。

string connString = "Data Source=drcsrv01;Initial Catalog=pubs;Integrated Security=True";
using(SqlConnection pubConnection = new SqlConnection())
{
        pubConnection.ConnectionString = connString;
        pubConnection.Open();
        //work with data
}

您应该养成为任何实现了IDispose接口的类使用 using 模式的习惯。下面的代码使用这个模式，通过使用StreamReader类来打开和读取一个文件。

string path = @"c:\temp\MyTest.txt";
using (StreamReader sr = File.OpenText(path))
{
    string s = "";
    while ((s = sr.ReadLine()) != null)
    {
        // work with text
    }
}

本讨论为您提供了对第八章的补充，涵盖了有效处理异常和使用 .NET Framework 异常类。请参见第八章对该主题的基本讨论。

十九、附录三：安装所需的软件

我在这本书里包含了许多学习活动。为了从我讨论的主题中获得最大的收获，你应该完成这些活动。这是理论具体化的地方。我希望你能认真对待这些活动，并彻底完成它们，甚至反复完成。

第一部分中的 UML 建模活动是为使用 UMLet 的人准备的。我选择这个程序是因为它是一个很好的学习图表的工具。它使您能够创建 UML 图，而无需添加许多高级功能。 UMLet 是一个免费的开源工具，可以从http://www.umlet.com下载。但是你不需要一个工具来完成这些活动；纸和铅笔就可以了。

第二部分中的活动需要安装了 C# 的 Visual Studio 2012。您可以使用免费版的 Visual Studio 2012 Express，也可以使用试用版的 Visual Studio 2012 Professional。这些版本在http://msdn.microsoft.com/en-us/vstudio/有售。我鼓励你安装帮助文件，并在完成活动时充分利用它们。

第三部分中的活动需要 Microsoft SQL Server 2008 R2 或 SQL Server 2012。您可以使用免费版本的 SQL Server Express 或在http://msdn.microsoft.com/en-us/sqlserver/提供的 SQL Server 试用版。安装 SQL Server 时，请确保将自己添加为管理员。

安装示例数据库

安装本书中使用的示例数据库的脚本可以从http://www.apress.com/9781430249351下载(向下滚动并点击源代码选项卡)。为了安装脚本，请按照下列步骤操作:

1. 打开命令提示符窗口。

2. 在命令提示符下，使用 cd 命令导航到包含示例数据库脚本的文件夹。

   cd c:\SampleDatabases
   

3. 运行 SQLCmd.exe，指定instOSODB.sql为输入文件。

4. 要在默认实例上安装数据库，请使用

   SQLCmd.exe -E -i instOSODB.sql
   

5. 要在命名实例上安装数据库，请使用

   SQLCmd.exe -E -S ComputerName\InstanceName -i instOSODB.sql
   

6. 对instpubs.sql和instnwnd.sql文件重复上述步骤。

注意您也可以使用 SQL Server Management Studio 来创建数据库。

验证数据库安装

要验证数据库安装:

1. Start Visual Studio. If you don’t see the Server Explorer window shown in Figure C-1, open it by choosing Server Explore on the View menu.

   

   图 C-1 。服务器资源管理器窗口

2. In the Server Explorer window, right-click the Data Connections node and select Add Connection. In the Add Connections dialog box shown in Figure C-2, fill in the name of your server, select the Northwind database, and click OK.

   

   图 C-2 。“添加连接”对话框

3. Expand the Northwind database node and the Tables node in the Database Explorer window, as shown in Figure C-3.

   

   图 C-3 。展开“表”节点

   注意如果你正在使用 SQLExpress 你需要使用服务器名和实例名(LocalHost\SQLExpress)来连接。

4. Right-click the Suppliers table node and select Show Table Data. The Suppliers table data should display as shown in Figure C-4.

   

   图 C-4 。查看表格数据

5. 重复这些步骤来测试pubs和OfficeSupply数据库。测试后，退出 Visual Studio。

标签：控件,入门,--,代码,对象,面向对象编程,使用,NET,应用
From： https://www.cnblogs.com/apachecn/p/18352667