C#进阶指南：XAML企业应用设计与开发

5星 · 超过95%的资源需积分: 10 200 浏览量更新于2024-07-21 2 收藏 9.27MB PDF 举报

《Pro XAML with C#》是一本由Apress在2015年出版的专业书籍，专注于在.NET框架下利用C#语言开发企业级应用程序，特别关注WPF（Windows Presentation Foundation）、Windows Store和Windows Phone三种平台的应用设计与构建。这本书适合有一定C#编程经验和至少一种XAML技术背景（如WPF、Silverlight）的中级到高级开发者阅读。本书结构分为三个部分： 1. **入门篇** (Part I: Getting Started) - 第1章介绍了XAML的基本概念，帮助读者理解这是一种用于声明性编程的语言，能够简化用户界面的设计。 - 第2章探讨了软件工匠精神，强调了代码质量和可维护性的重要性，为后续章节打下坚实的基础。 2. **基础篇** (Part II: Laying the Groundwork) - 第3章阐述了领域驱动设计（Domain-Driven Design），这是构建业务逻辑和模型的重要原则。 - 第4章涵盖了设计模式，提供了在XAML和C#中实现常见设计模式的实际例子，有助于提高开发效率和代码质量。 - 第5章和第6章深入讲解单元测试，不仅介绍基本的单元测试技术，还讨论了高级测试和测试驱动开发（TDD）策略。 - 第7章讨论了异常处理和日志记录，确保应用的健壮性和可调试性。 3. **用户界面篇** (Part III: Completing the User Interface Layer) - 第8章详细介绍了在WPF中创建高效且美观的用户界面，包括控件、布局和事件处理。 - 第9章转向Windows Phone平台，展示了针对移动设备优化的UI设计和交互方式。 - 第10章则扩展到了Windows用户界面，可能涉及到不同版本和特性的兼容性处理。 - 最后，第11章着重于部署和维护应用程序，包括发布流程、性能优化和持续集成/持续部署(CI/CD)实践。通过本书，读者将不仅掌握XAML和C#语言的深入结合，还能提升软件开发的整体技能，适应企业级应用开发的需求。无论是对于初入此领域的开发者还是寻求技术进阶的专家，都能从中获益良多。同时，作者对软件工程理念的重视，使得本书不仅限于技术层面，更包含丰富的行业洞见和实践经验。

CHAPTER 1 ■ WHAT IS XAML?

public string LastName

{

get { return _LastName; }

set

{

_LastName = value;

OnPropertyChanged("LastName");

}

public event PropertyChangedEventHandler PropertyChanged;

public void OnPropertyChanged(string propertyName)

{

if (PropertyChanged != null)

PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

}

As you can see, the model is simple. It represents a Person entity. There are two properties exposed,

FirstName and LastName. The class implements the interface InotifyPropertyChanged, which allows the

model to alert the view model of any property changes. Finally, Listing 1-6 shows the source code for the

view model class.

Listing 1-6. The C# Code for MainWindowViewModel.cs (the View Model)

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace BasicMVVMWPF

{

public class MainWindowViewModel : INotifyPropertyChanged

{

private PersonModel _Model;

private string _FullName;

public MainWindowViewModel()

{

_Model = new PersonModel

{

FirstName = "Buddy",

LastName = "James"

};

this.FullName = string.Format("{0} {1}", _Model.FirstName, _Model.LastName);

}

www.it-ebooks.info

Chapter 2

Software Craftsmanship

“The proof is in the pudding!”

Software as an Art and a Science

Now that we’ve covered the Extensible Application Markup Language (XAML) and its different “dialects,”

or anomalies that exist between WPF, Windows 8.1/Windows Store, and Windows Phone 8.1 XAML, we

can concentrate on the design patterns and industry best practices that you’ll use throughout the rest of

this book to design and develop a “smart client” line-of-business (LOB) application. The primary idea of

this book is to take you through the experience of working with a virtual (fictional) team. Doing so will aid

you in learning the key concepts involved by presenting some of the common issues that you will face and

providing you with tips that will resonate with you no matter what area of IT you work in.

The patterns and paradigms presented in this book will provide you with the information you’ll need to

design and develop robust, reusable, business domain–related software solutions that solve problems found

in the enterprise while using effective design methodologies, design patterns, and other tools that are used

throughout the software development community.

The book will offer tips and tricks on how to achieve the highest level of user interface layer component

reuse between the three XAML-based target platforms. The applications in this book are designed with

flexibility in mind. The book will concentrate on the SOLID object-oriented design principles to aid you

when designing the classes that make up your applications. The ultimate goal is to illustrate how to design

applications that are divided into logical layers that promote a clear separation of concerns. Physically, the

layers will represents class libraries that are concise, flexible, extensible, and loosely coupled from other

components throughout the system. This will maximize code reuse throughout your organization, as well as

make your code easier to write unit tests for.

SOLID Object-Oriented Design

The S in SOLID stands for the Single Responsibility principle. This principle means that a class should have

one and only one responsibility. As an example, your Order class shouldn’t be concerned with how yearly

reports are printed. This would be the responsibility of a class called ReportPrintService. The Order class

should be responsible only for describing an order in the system.

The O in SOLID stands for the Open/Close principle. This means you should design your code to be

open to extensibility and closed to modification. You may ask yourself, “How can I make a class open to

being extended without modifying the code?” There are several ways to assist you with this principle. For

instance, you could create a base class and inherit from the base class to implement methods on your own.

Our favorite approach is a design pattern called the Decorator pattern. You can find the official definition at

http://sourcemaking.com/design_patterns/decorator.

www.it-ebooks.info

CHAPTER 2 ■ SOFTWARE CRAFTSMANSHIP

“The Decorator Pattern attaches additional responsibilities to an object dynamically.

Decorators provide a flexible alternative to subclass for extending functionality.”

We will provide a full example of this pattern, as well as other useful design patterns, later in this

chapter. The L in SOLID stands for the Liskov substitution principle. This means you should be able to

reference an instance of your class as any base class or any interface in which the class implements.

The I in SOLID stands for the Interface Segregation principle, which states that when possible, you should code

to an interface rather than a concrete implementation. Finally, the D in SOLID stands for the Dependency

Inversion principle, which promotes two patterns: Dependency Injection (DI) and Inversion of Control.

■ Note The SOLID object design principles represent an acronym in which each letter represents a principle

to consider when designing a class, property, or method in object-oriented design.

To Unit Test or Not to Unit Test?

The topic of unit testing spurs debates where each participant feels strongly about their stance. One party

might say, “Unit tests sound great in theory, but I don’t have time to meet deadlines and write unit tests

from which I gain nothing!” Another individual may insist, “Unit tests are the best thing since sliced bread

and the butter that you put on it!” A third party may make the claim, “I’ve written code for more than

20 years just fine without unit tests.” Finally, there may be an individual who believes, “With unit tests,

I know the moment that a bug is introduced into the system, as well as where to find it.” These are just a few

of the arguments that come to mind.

There is no absolute “correct” answer. Honestly, does unit testing add extra development time?

Generally, the answer is “yes.” Does unit testing help reduce the bugs in an application? There have been

many studies that suggest that unit testing does in fact help make your code less error prone. Just like

anything else, unit testing takes practice to gain proficiency, which means that your unit tests will provide

quality protection only when they are quality tests. You have to know what to test and what unit tests are

redundant or misleading. Practice makes perfect!

Test-Driven Development

While we are on the topic of unit tests, we’re obligated to talk a bit about Test-Driven Development (TDD).

TDD is a software development paradigm in which you write unit tests before you even implement the class

under testing. If you write each test before the method you are testing, you guarantee that all methods will be

covered with a unit test.

There is another benefit to using TDD that many people overlook. If you write a unit test for the method

PrintService.PrintReport() before a PrintService.PrintReport() exists, then you are designing the

method and the public contract of the PrintService class. This design is based on how you would naturally

imagine the class should be used. Thus, not only do you guarantee that each method has at least one unit

test associated with it, you also get to design your classes based on how you would use the class. When the

unit test is finished, it can serve as a succinct example of how the class should be used.

www.it-ebooks.info

剩余278页未读，继续阅读

vanridin

粉丝: 108
资源: 1187

C#进阶指南：XAML企业应用设计与开发

ProXAMLwithC#

Pro XAML with C#

Learn wpf mvvm-xaml,C# and the mvvm pattern

WPF XAML代码和C#代码转换

c# with open

例子C#和axaml

c#xaml中怎么连接串口

c# xaml安卓串口通讯

如何用c#编码实现xaml转html

将这行xaml代码转为C#：<Button Style="{DynamicResource ButtonStyle}" Content="Copy" Name="c" Grid.Row="2" Grid.Column="0" Margin="3"/>

最新资源