BOOKS FOR PROFESSIONALS BY PROFESSIONALS® James Lalonde Pro XAML with C# RELATED Packed with real, usable code and expert insights, Pro XAML with C# shows you how to design and build compelling enterprise applications on WPF, Windows Store, or Windows Phone, or any combination of the three. In Part I, authors Buddy James and Lori Lalonde introduce you to XAML and reveal proven techniques for developing successful line-of-business applications. You’ll also find out about some of the conflicting needs and interests that you might encounter as an enterprise XAML developer. Part II begins to lay the groundwork to help you properly architect your application, providing you with a deeper understanding of domain-driven design and the Model-View-ViewModel design pattern. You will also learn about proper exception handling and logging techniques, and how to cover your code with unit tests to reduce bugs and validate your design. Part III explores implementation and deployment details for each of Microsoft’s XAML UIs, along with advice on deploying and maintaining your application across different devices using version control repositories and continuous integration. Pro XAML with C# is for intermediate to experienced developers. Readers should have experience working with C# and at least one XAML-based technology (WPF, Silverlight, Windows Store, or Windows Phone). Shelve in Category ISBN 978-1-4302-6776-8 .NET 55499 User level: Intermediate–Advanced SOURCE CODE ONLINE 9781430267768 www.apress.com For your convenience Apress has placed some of the front matter material after the index. Please use the Bookmarks and Contents at a Glance links to access them. Contents at a Glance About the Authors ��������������������������������������������������������������������������������������������������xiii About the Technical Reviewer ���������������������������������������������������������������������������������xv Acknowledgments �������������������������������������������������������������������������������������������������xvii Introduction ������������������������������������������������������������������������������������������������������������xix ■ Part I: Getting Started ������������������������������������������������������������������������1 ■ Chapter 1: What Is XAML? �������������������������������������������������������������������������������������3 ■ Chapter 2: Software Craftsmanship ��������������������������������������������������������������������15 ■ Part II: Laying the Groundwork ���������������������������������������������������������25 ■ Chapter 3: Domain-Driven Design �����������������������������������������������������������������������27 ■ Chapter 4: Design Patterns ����������������������������������������������������������������������������������37 ■ Chapter 5: Unit Testing ����������������������������������������������������������������������������������������57 ■ Chapter 6: Advanced Unit Testing and Test-Driven Development ������������������������77 ■ Chapter 7: Exception Handling and Logging ��������������������������������������������������������97 ■ Part III: Completing the User Interface Layer ��������������������������������123 ■ Chapter 8: The WPF User Interface �������������������������������������������������������������������125 ■ Chapter 9: The Windows Phone User Interface �������������������������������������������������159 ■ Chapter 10: The Windows User Interface ����������������������������������������������������������195 ■ Chapter 11: Deploying and Maintaining Your Application ���������������������������������219 Index ���������������������������������������������������������������������������������������������������������������������265 iii Introduction I started developing applications in .NET, using WinForms and ASP.NET. WinForms was a great improvement over Visual Basic 6. ASP.NET WebForms introduced a form-focused, event-driven user interface model similar to WinForms. A major difference was the way in which the user interface was defined. Visual Studio offered WYSIWYG design support for both technologies. The key difference was that WinForms user interfaces were represented in procedural C# and ASP.NET WebForms that were built in declarative HTML. I’ve always loved the expressive nature of HTML. Even though I preferred developing user interfaces for the Web, desktop applications seemed to offer more power. I like to have complete access to the computer’s resources. Microsoft released WPF with the .NET Framework version 3.0. I will admit that there was a bit of a transition for me. WPF was a little intimidating. I had to think about things in a completely different manner. The lessons that I learned went beyond the new controls and events. As I learned about data binding, I began to learn about the Model View View Model design pattern, also known as MVVM. When Microsoft released Windows 8 and Windows Phone 8, I was thrilled to learn that XAML was one of the language choices. Microsoft also introduced the Windows Runtime libraries, also known as WinRT. WinRT offered APIs to support new devices such as tablets and phones. With the release of Windows 8.1 and Windows Phone 8.1, the ability to create Universal Applications projects enabled developers to create Windows Store and Windows Phone applications that share common code, assets, and XAML UIs between both platforms. The Universal Application development experience has been improved in Windows 10 to allow you to create one project that can be deployed to both Windows Store and Windows Phone devices. If you are developing for your desktop, tablet, or phone, you can use XAML to design the user’s experience. —Buddy James What This Book Covers This book was written with two goals in mind. First, we wanted to cover the XAML-based user interface technologies. The second goal was to introduce some common software development practices and design patterns that are used in the enterprise today. We will also cover some development tools and libraries that you can use to aid you in your work. Chapter 1: What Is XAML? This chapter is an introduction to XAML. We explain the difference between declarative and procedural programming. We discuss how XAML development is different than other Microsoft development technologies. There is a brief introduction to the MVVM design pattern and how the data binding capabilities of XAML support the implementation of the pattern. xix ■ IntroduCtIon Chapter 2: Software Craftsmanship Software development is constantly changing. This chapter discusses agile development methodologies and the problems that they solve. We cover object-oriented design goals and how leading your design by developing unit tests first can assist you in achieving these goals. We cover development teams and requirements gathering in this chapter as well. Chapter 3: Domain-Driven Design Programming professionally is more about solving business problems than writing source code. Domain-Driven Design is a set of software design principles that support agile development practices where customer participation is required to ensure that you deliver applications that meet the needs and expectations of your clients. We briefly cover some of the software design principles that are used in Domain-Driven Design. Chapter 4: Design Patterns Design patterns offer uniform solutions to common problems in software development. This chapter covers layered architecture and several design patterns to assist you in your development efforts. We present an MVVM example in WPF to illustrate the benefits of design patterns in XAML-based applications. Chapter 5: Unit Testing Unit testing can help you reduce the number of bugs that you introduce into your software during development. Writing unit tests can also improve your design by illustrating the ways in which your classes are meant to be used. Chapter 6: Advanced Unit Testing and Test-Driven Development This chapter builds on the last one by introducing some of the advanced topics in unit testing. This chapter provides an introduction to mocks and stubs, which allow you to write unit tests that execute in the same way each time, even if your code relies on third-party APIs and components. We cover unit testing in Visual Studio as well as NUnit. There is also an in-depth look at Test-Driven Development. Chapter 7: Exception Handling and Logging Exception handling is a fundamental task in .NET development, and it safeguards against unexpected application crashes. It is equally important to record data associated with any exceptions, which will assist with troubleshooting issues that arise in production. This chapter covers the Microsoft patterns and practices Exception Handling Application Block, as well as the Logging application block and its usage within WPF applications. We wrap up the chapter with alternative approaches to handling exceptions and logging within your Windows Store applications. xx ■ IntroduCtIon Chapter 8: The WPF User Interface This chapter provides an introduction to WPF development using XAML to design your user interfaces. WPF-specific controls and design concerns are covered. We also demonstrate how XAML resources and styles allow you to create a common look and feel across your entire application. The chapter concludes with a detailed discussion on data binding techniques to manage data flow within the application. Chapter 9: The Windows Phone User Interface This chapter covers Windows Phone development concepts using XAML and C#. We discuss the basic structure of a Windows Phone Store application and how you can design your application for various screen sizes and page orientations. The various presentation controls are covered, and we show how you can use them to display application content while maximizing screen real estate. We also demonstrate how to display data collections and how to configure the Application Bar. Chapter 10: The Windows User Interface Windows Store applications are fundamentally different than desktop-based applications. The user interface design standards promote simple, clean user interfaces that are focused on content. In this chapter, we provide you with the basics you need to get your environment set up for Windows 8.1 development. We also cover topics that are specific to Windows Store applications, such as flyouts, Windows 8.1 contracts, and how to adapt to different layouts. Chapter 11: Deploying and Maintaining Your Application The last chapter of the book is dedicated to the deployment and maintenance of your application. Source control best practices are explained, as well as an overview of the popular version control systems, TFS and Git. You will learn how to deploy WPF applications using ClickOnce deployment, as well as how to submit your Windows 8.1 and Windows Phone 8.1 applications to the Windows Store. Who This Book Is For This book is for all .NET developers who are interested in developing software using Microsoft’s XAML-based technologies. The book requires a working knowledge of C#. To get the most out of this book, we recommend some experience with at least one XAML-based technology. The examples in this book were developed using Visual Studio 2012 and Visual Studio 2013. You will need experience designing and compiling applications in Visual Studio to build the example source code. The minimum framework version when developing WPF applications is .NET Framework 3.0. The minimum framework version when developing Windows 8.1 and Windows Phone 8.1 applications is .NET Framework 4.5.1. xxi Part I Getting Started Chapter 1 What Is XAML? This chapter is a “crash course” in Extensible Application Markup Language (XAML). If you are experienced in writing applications using XAML-based technologies, feel free to skim the chapter and pick the parts that interest you. If you don’t have experience writing XAML-based applications, then this chapter is a prerequisite for the rest of the book. A Brief History of Windows User Interface Design Before XAML was introduced to the development community, Windows desktop applications were mainly created using the WinForms technology. The WinForms design paradigm is similar to Visual Basic 6–style graphical user interfaces (GUIs) of old. You work within a what-you-see-is-what-you-get (WYSIWYG) interface that allows you to drag controls from a toolbox and drop them on the window. Visual Studio serialized the user interface in the designer as C# code that contained object declarations for all user interface controls along with property values and other details required to represent the user interface. This meant that if you were working in an environment where the team was made up of designers and developers, collaboration between the two groups was difficult. If a designer wanted to apply a common theme to a user interface, they would often create bitmap mock-ups and divide the mock-ups into smaller bitmaps to be used for each control on the form. These bitmaps would then need to be applied to each control as some property, such as the background. This process was tedious and inefficient. Bitmap-based designs don’t scale well, and resizing the controls on a form caused the associated bitmaps to resize, which would often result in degraded image quality. Enter XAML. Extensible Application Markup Language XAML (pronounced “zammle”) is based on Extensible Markup Language (XML) and is for designing user interface layouts. XAML is known as a declarative language. It is almost always used in conjunction with another type of programming language known as an imperative language, such as C#, VB.NET, C++, and so forth. XAML-based technologies covered in this book include the following: • Windows Presentation Foundation (WPF): XAML + C# + WPF assemblies • Windows 8.1/Windows Store development: XAML + C# + Windows Store assemblies • Windows Phone 8.1: XAML + C# + Windows Phone assemblies 3 Chapter 1 ■ What Is XaML? Each of these technologies uses XAML in combination with another .NET programming language, such as C# or VB.NET, to create desktop, tablet, and mobile applications with stunning and unique user interfaces as well as elegant and intuitive user experience designs, which were nearly impossible to achieve prior to the introduction of XAML and WPF in .NET 3.0. Since XAML is an XML-based declarative markup language, it adds a completely new paradigm to Windows-based user interface (UI) development. XAML is verbose and thus easily read by humans. This is helpful when you need to edit XAML by hand. Moreover, the XML basis of XAML makes it an easy language for which WYSIWYG editors can be created. I know, I know—right now you are probably thinking, “XML may be easy to read, but what about the performance of my application? XML is too verbose!” This is true. XML can cause performance problems when parsing; however, the XAML parser will compile your XAML into a binary format called Binary Application Markup Language (BAML) that is used during the execution of your application. BAML drastically reduces the size of your XAML code, and this helps to eliminate the performance problems associated with traditional XML parsing. BAML is tokenized as well so that duplicate references throughout the BAML code can be replaced by much smaller tokens. This in turn makes BAML code even smaller and thus faster during application execution. Separation of User Interface Concerns One of the great things about this new user interface design paradigm is the synergy it provides between developers and designers. Unlike technologies of the past, XAML includes code-behind associations, although this is not a requirement. In contrast to WinForms, XAML does not require the designer to create a C# representation of the user interface. XAML is designed to be all that is needed to define the look and feel of your user interface. This aspect of XAML, along with important new features such as data binding, routed events, and attached properties, which we’ll discuss throughout the book, allows XAML-based applications to take advantage of user interface design patterns that allow the complete separation of the user interface design (XAML) and presentation layer logic (C#). This book will focus on the Model-View-ViewModel (MVVM) design pattern, which will be covered in depth in later chapters. There are other design patterns that you can use with XAML based user interfaces that allow you to separate your user interface design from the presentation layer logic, and you should definitely look into some of them. Table 1-1 provides references to two other great design patterns that you should explore. Table 1-1. User Interface Design Pattern References Design Pattern Name Reference URL Model-View-Controller (MVC) https://msdn.microsoft.com/en-us/library/ff649643.aspx Model-View-Presenter (MVP) https://msdn.microsoft.com/en-us/magazine/cc188690.aspx Declarative vs. Imperative Programming In declarative programming, the source code is written in a way that expresses the desired outcome of the code with little or no emphasis on the actual implementation. This leaves the framework to deal with parsing the declarative source code and handling the “heavy lifting” required to instantiate objects and set properties on the these objects, which are defined in the XAML elements. Imperative programming is the opposite of declarative programming. If declarative programming can be thought of as declaring what the desired outcome is, imperative programming can be viewed as writing lines of code that represent the instructions of how to achieve the desired outcome. 4 Chapter 1 ■ What Is XaML? A great example of a declarative language and an imperative language working together is XAML and C#. Whether you are developing a smart client desktop application using WPF, a Windows Store app for use with tablets such as the Microsoft Surface Pro, or a mobile application using Windows Phone, any of these applications can be developed using a mixture of XAML and C#. ■ Note When it comes to the imperative .Net languages, you are not limited to C#. Depending on the target platform, you can use C#, VB.Net, and even F#. a search of the Internet reveals that C# is generally the language of choice when using WpF, Windows store apps, and Windows phone 8, so that’s the language we’ll use for the code examples throughout this book. Let’s begin by looking at the declarative XAML markup used to define a WPF Window. Listing 1-1 shows a basic WPF Window with a grid and a button control written declaratively in XAML. Listing 1-1. Declarative Source Code Written in XAML <Window x:Class="WpfApplication1.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"> <Grid> <Button Name="btnOK"> <TextBlock Name="ButtonText" FontSize="100"> Click Me! </TextBlock> </Button> </Grid> </Window> If you don’t have experience with XAML, don’t worry about the syntax. Instead, note the aspects of declarative programming. You see what looks to be an XML file that contains a root element called Window. The elements in XAML are associated with a class in which the parser will create an instance of the specified type during runtime. The attributes of these elements are directly linked to the properties of the object that the element represents. The element has attributes as well as nested elements. The nested elements can also be used as property values of the parent element’s instance. For example, notice that there is a Grid element, and within the start and end of the Grid element tags, there is a Button element. Much like the other elements, the Button element has a nested TextBlock element. In this case, the TextBlock element represents an instance of the TextBlock type that is assigned to the Content property of the Button element’s object instance. Perhaps an example will assist in explaining how elements defined in XAML and their attributes and nested elements are related to object instances and property values. Just as Listing 1-1 shows the XAML definition of a WPF window using declarative programming, Listing 1-2 contains C# code to build a WPF window imperatively, which is identical to the window created declaratively in Listing 1-1. 5