Windows Presentation Foundation 4.5 Cookbook

Windows Presentation Foundation 4.5 Cookbook

By : Pavel Yosifovich

Buy this Book

Windows Presentation Foundation 4.5 Cookbook

By: Pavel Yosifovich

Buy this Book

Overview of this book

Windows Presentation Foundation (WPF) provides developers with a unified programming model for building rich Windows smart client user experiences that incorporate UI, media, and documents.WPF has become the leading technology for developing rich client applications on the Windows platform, packed with features and capabilities. However, WPF is big; in fact, it's huge, causing a steep learning curve for the beginner and even for those already using some WPF features.Windows Presentation Foundation 4.5 Cookbook provides clear recipes for common WPF tasks. It includes detailed explanations and code examples for customizing and enhancing the basic scenarios, while gaining a deep understanding of WPF mechanics and capabilities.WPF is different and requires a different mind-set and approach. This book provides recipes and insights not only in its design but also its practical implementation details.Starting from the foundations of WPF, such as dependency properties and XAML, the book touches on all major WPF aspects, such as controls and layout, resources, and digs deep into its unprecedented data binding capabilities.The book shows data and control templates in action, which allow full customizations of displayed data and controls in a declarative way. Supported by styles and resources makes data binding all the more powerful. The Model View View-Model pattern is presented as an effective way of maximizing decoupling of components, while providing an elegant way of expanding applications while maintaining a tight grip on complexity.The later parts discuss custom elements and controls ñ the ultimate customization mechanism, and looks at multithreading issues, and how .NET 4.5 task parallelism features can enhance application performance.

Windows Presentation Foundation 4.5 Cookbook

Credits

About the Author

About the Reviewers

www.PacktPub.com

Preface

Free Chapter

Foundations

Introduction

Creating custom type instances in XAML

Creating a dependency property

Using an attached property

Creating an attached property

Accessing a static property from XAML

Creating a custom markup extension

Handling routed events

Resources

Introduction

Using logical resources

Dynamically binding to a logical resource

Using user-selected colors and fonts

Using binary resources

Accessing binary resources in code

Accessing binary resources from another assembly

Managing logical resources

Layout and Panels

Introduction

Creating a table-like user interface

Dynamically sizing grid rows/columns

Creating a scrollable user interface

Creating a border around panels and elements

Placing elements in exact positions

Adding/removing elements to a panel dynamically

Creating a tabbed user interface

Implementing drag-and-drop

Using Standard Controls

Introduction

Working with text

Using content controls

Displaying images

Creating tooltips

Creating a list of items

Creating a standard menu

Creating a context menu

Selecting options with checkboxes and radio buttons

Manipulating tab order and focus

Application and Windows

Introduction

Creating a window

Creating a dialog box

Using the common dialog boxes

Creating ownership between windows

Creating a custom shaped window

Creating a single instance application

Handling an unhandled exception

Data Binding

Introduction

Element to element binding

Binding to a single object

Binding to a collection

Using data templates

Using value converters

Creating a master-detail view

Sorting and filtering bound collections

Grouping bound collections

Binding to multiple properties

Binding hierarchical data to a TreeView

Presenting data in a grid

Validating data

Commands and MVVM

Introduction

Using routed commands

Implementing a basic MVVM application

Building a simple MVVM framework

Building a complete MVVM style application

Creating an undo/redo system

Styles, Triggers, and Control Templates

Introduction

Creating and using styles

Applying a style automatically

Creating a property trigger

Using data triggers

Creating an event trigger

Creating a multi trigger

Using behaviors

Replacing the control template of a progress bar

Replacing the control template of a scroll bar

Customizing selection in a Selector control

Graphics and Animation

Introduction

Creating a custom shape

Applying transforms on elements

Manipulating a bitmap programmatically

Creating adorners

Creating property-based animations

Creating path-based animations

Creating custom animations

Adding animation easing to animations

Using custom effects with pixel shaders

Custom Elements

Introduction

Creating a user control

Handling standard commands in a user control

Creating a custom (templated) control

Customizing a default template of custom control

Creating a custom panel

Creating a lightweight custom element

Threading

Introduction

Updating the UI from a non-UI thread

Adding cancelation support

Using the BackgroundWorker component

Adding cancellation and progress with BackgroundWorker

Using a timer to do periodic updates

Using C# 5.0 to perform asynchronous operations

Index

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Using C# 5.0 to perform asynchronous operations

Using synchronous operations is really easy. Just call some operation, wait for it to return, and use the result. As we've seen, the problem is that slow operations block the calling (UI) thread or that thread does some hard CPU bound work; in both cases, the UI may become unresponsive. We have seen several ways to deal with that. These require running the long operation on a different thread, and when the results are finally available, marshal some code to update the UI.

The net result is code complexity, which grows quickly with more and more asynchronous operations happening. And if we consider more than one operation at a time, potential cancellations, adding timeouts, handling exceptions conveniently – code complexity climbs quickly.

C# 5.0 has a new feature related to calling operations running asynchronously and waiting efficiently for the result without all the required marshaling and code complexity. In this recipe, we'll take a brief...

Windows Presentation Foundation 4.5 Cookbook

By : Pavel Yosifovich

Windows Presentation Foundation 4.5 Cookbook

By: Pavel Yosifovich

Overview of this book

Related Content you might be interested in

Current Title:

Windows Presentation Foundation 4.5 Cookbook

Using C# 5.0 to perform asynchronous operations