Transcript Document

WPF, Windows Presentation Foundation
A platform for building rich user experiences on Windows
An Architect overview
By Shahzad sarwar
Presentation Scope
• What's covered:
 XMAL
 Basic Elements of WPF
 Architecture
 Property System / Dependency Property
 Routed Events
 Binding System
 Styling / Templating
• What’s Not covered:
 Controls Library
Graphics / Multi Media
Documents
What is WPF?
• Next-generation presentation system for building Windows client
applications with visually stunning user experiences.
• Resolution-independent
• Vector-based rendering engine (advantage of modern graphics
hardware)
• Coverage:
Extensible Application Markup Language (XAML), controls, data
binding, layout, 2-D and 3-D graphics, animation, styles, templates,
documents, media, text, and typography.
Types Of Applications:
1. Standalone Applications:


Window class to create windows and dialog boxes
Accessed from menu bars and tool bars.
2. Browser-Hosted Applications:
(XAML browser applications (XBAPs))
 Create pages (Page) and page functions (PageFunction(T))
 Navigate between using hyperlinks (Hyperlink classes).
Tech Analysis
WinForm
s
Forms,
Controls
Complex text
Images
PDF
X
WinForm
s+
GDI
3D Graphics
Direct3D
WPF
X
X
X
X
X
X
Video / Audio
2D Graphics
Windows
Media
Player
X
X
X
X
X
X
Reference: http://windowsclient.net/wpf/white-papers/when-to-adopt-wpf.aspx
The Application Class
Additional application-scoped services, including
 Creating and managing common application infrastructure.
 Tracking and interacting with application lifetime.




Startup
Activated
Deactivated
ShutdownMode
(OnLastWindowClose,OnMainWindowClose,
OnExplicitShutdown)
 SessionEnding
(Logging off,Shutting down,Restarting,Hibernating)
 Exit
 Retrieving and processing command-line parameters.

Example
 Sharing application-scope properties and resources.

Examples in Code
 Detecting and responding to unhandled exceptions.

Example in Code
The Application Class

Returning exit codes.
Example in Code

Managing windows in standalone applications

Tracking and managing navigation
using System.Windows.Navigation;
1. <Hyperlink Control
<Hyperlink NavigateUri="UriOfPageToNavigateTo.xaml">
Navigate to Another Page
</Hyperlink>
2. Via NavigationService
// Instantiate the page to navigate to
PageWithNonDefaultConstructor page = new
PageWithNonDefaultConstructor("Hello!");
// Navigate to the page, using the NavigationService
this.NavigationService.Navigate(page);
The Application Class
3.Programmatic Navigation with a Pack URI
// Create a pack URI
Uri uri = new Uri("AnotherPage.xaml", UriKind.Relative);
// Get the navigation service that was used to
// navigate to this page, and navigate to
// AnotherPage.xaml
this.NavigationService.Navigate(uri);
 Configuring the Host Window's Title, Width, and
Height
 Fragment Navigation
Navigation to a content fragment
PageURI#ElementName
Navigation Lifetime
• Navigating. Occurs when a new navigation is requested. Can be
used to cancel the navigation.
• NavigationProgress. Occurs periodically during a download to
provide navigation progress information.
• Navigated. Occurs when the page has been located and
downloaded.
• NavigationStopped. Occurs when the navigation is stopped (by
calling StopLoading), or when a new navigation is requested while a
current navigation is in progress.
• NavigationFailed. Occurs when an error is raised while navigating
to the requested content.
• LoadCompleted. Occurs when content that was navigated to is
loaded and parsed, and has begun rendering.
• FragmentNavigation Occurs when navigation to a content fragment
begins, which happens:
– Immediately, if the desired fragment is in the current content.
– After the source content has been loaded, if the desired fragment is in
different content.
Navigation Lifetime
Navigation Lifetime
 Journal / journal entry(JournalEntry class)
The back stack, the forward stack
1. Declarative mechanisms provided by WPF
<Hyperlink Members of the NavigationService
classCommand="NavigationCommands.BrowseBack">Back</Hyper
link>
2. Programmatic mechanisms provided by WPF
GoBack
GoForward
CanGoBack
CanGoForward
 Retaining Content State with Navigation History
 New Page, so data is destroyed, But there is a mechanism to restore
state via Journal like navigation history.
 Custom implementation is also provided
System.Windows.Navigation.CustomContentState
Navigation Lifetime
 Structured Navigation Overview
Structured Navigation with PageFunction
Other Types of Structured Navigation
 NavigationWindow Class
browser-style navigation into your standalone applications
Navigation Hosts
 Configuring the Application Definition for MSBuild
In MSBuild project
<ApplicationDefinition Include="App.xaml" />
Getting the Current Application
// Get strongly-typed current application
App app = (App)App.Current;
 Two way to Start Window or Page
1. ByCode
void App_Startup(object sender, StartupEventArgs e)
{
((NavigationWindow)this.MainWindow).Navigate(new Uri("HomePage.xaml",
UriKind.Relative));
}
2. StartupUri="MainWindow.xaml"
WPF Architecture
WPF Architecture
 More declarative, "property centric" model of programming
 System.Threading.DispatcherObject
 Support for concurrency and threading.
 messaging system implemented by the dispatcher.
 Create a CLR object that has STA behavior.
 Thread affinity:
 A component uses the identity of the executing thread to store some type of
state.
 OLE 2.0, the clipboard, and Internet Explorer all require single thread affinity
(STA) execution.
 The dispatcher:
 Basic message dispatching system, with multiple prioritized queues
 Examples of messages include:



Raw input notifications (mouse moved)
Framework functions (layout)
User commands (execute this method).
WPF Architecture
 System.Windows.DependencyObject
 Dependency Properties:
To compute the value of a property based on the value of
other inputs
 System properties such as themes and user preference
 Just-in-time property determination mechanisms such as data
binding and animations/storyboards
 Multiple-use templates such as resources and styles
 Values known through parent-child relationships with other
elements in the element tree
Also For:
 Self-contained validation
 Default values
 Callbacks that monitor changes to other properties
 A system that can coerce property values based on potentially
runtime information.
WPF Architecture
 System.Windows.Media.Visual
 Building a tree of visual objects
 Drawing instructions and metadata about how to render
those instructions
(clipping, transformation, etc.).
 Point of connection between these two subsystems, the
managed API and the unmanaged milcore.
WPF Architecture
 Composition:
 In User32 and GDI:
 (Immediate mode clipping system)
 a clipping bounds outside of which the component isn’t allowed
to touch the pixels, and then the component is asked to paint
pixels in that box.
 Good for memory constrained environment.
 In WPF:





"Painter's algorithm" painting model.
To render from the back to the front of the display.
Each component to paint over the previous component's display.
Complex, partially transparent shapes.
Better for new type of graphics object.
WPF Architecture

System.Windows.UIElement
Core subsystems including Layout, Input, and Events.

Layout:
1. A fixed set of layout models (HTML supports three models for layout; flow, absolute, and
tables)
2. No model for layout (User32 really only supports absolute positioning)
A flexible, extensible layout model, which could be driven by property values rather than
imperative logic.

A two phase model with Measure and Arrange passes.

Measure Phase: To determine how much size it would like to take.




A parent element will ask a child to measure several times to determine its optimal position and size.
Rule: Size to content.
Arrange phase: To allows a parent to position and determine the final size of each child.
Input:





On a kernel mode device driver.
Gets routed to the correct process and thread by involving the Windows kernel and User32.
Routed to WPF.
WPF raw input message and sent to the dispatcher.
Raw input events to be converted to multiple actual events.
WPF Architecture
 Routing through the element tree.
 Events are said to "bubble" if they traverse from a target up
the tree to the root.
 Events are said to "tunnel" if that start at the root and
traverse down to a target.
 In the dispatcher for your application you would call
TranslateAccelerator which would sniff the input
messages in User32 and determine if any matched a
registered accelerator.
 CommandBindings.
 To define functionality in terms of a command end point –
something that implements ICommand.
 Enable an element to define a mapping between an input
gesture (Ctrl+N) and a command (New).
WPF Architecture
 System.Windows.FrameworkElement
 A set of policies and customizations on the subsystems introduced in
lower layers of WPF.
 A set of new subsystems
 Policies:
 Application layout
 Direct access to animation through the BeginStoryboard method
 The data binding subsystem: one or more properties from a given element
to be bound to a piece of data
 Styling Subsystem: Bind a set of properties from a shared definition to one
or more instances of an element.
 System.Windows.Controls.Control
 Templating allows a control to describe it’s rendering in a parameterized,
declarative manner.
 The implementation of a control provides a data model and interaction
model
 This split between the data model (properties), interaction model
(commands and events), and display model (templates) enables complete
customization of a control’s look and behavior.
WPF property system
 A set of services that can be used to extend the functionality of a common
language runtime (CLR) property.
 Dependency property:
A property that is backed by the WPF property system.
 What For?
 1. A way to compute the value of a property based on the value of other
inputs
 System properties such as themes and user preference
 Just-in-time property determination mechanisms such as data binding and
animations/storyboards Multiple-use templates such as resources and styles
 Values known through parent-child relationships with other elements in the
element tree.
 2. To provide self-contained validation, default values, callbacks that monitor
changes to other properties
 3. A system that can coerce property values based on potentially runtime
information.
 4. Derived classes can also change some specific characteristics of an
existing property by overriding dependency property metadata, rather than
overriding the actual implementation of existing properties or creating new
properties.
Common Terms
 DependencyProperty: Extend property functionality by providing a
type that backs a property
 DependencyObject: The base class that can register and own a
dependency property
 Dependency property identifier: A DependencyProperty instance,
which is obtained as a return value when registering a dependency
property, and then stored as a member of a class.
 CLR "wrapper": The actual get and set implementations for the
property
public static readonly DependencyProperty IsSpinningProperty =
DependencyProperty.Register(
...
);
public bool IsSpinning
{
get { return (bool)GetValue(IsSpinningProperty); }
set { SetValue(IsSpinningProperty, value); }
}
Setting Property Values
 1. XAML attribute
<Button Background="Red"
Content="Button!"/>
 2. Property element syntax.
<Button Content="Button!">
<Button.Background>
<ImageBrush ImageSource="wavy.jpg"/>
</Button.Background>
</Button>
 3. Setting Properties in Code
Button myButton = new Button();
myButton.Width = 200.0;
Routed events
 A type of event that can invoke handlers on multiple listeners in an element
tree, rather than just on the object that raised the event.
 CLR event that is backed by an instance of the RoutedEvent class and is
processed by the Windows Presentation Foundation (WPF) event system.
 Routed events are events who navigate up or down the visual tree acording
to their RoutingStrategy.
 Top-level Scenarios for Routed Events
 Control composition and encapsulation:
 Eg: Rich content model. Like an image inside of a Button.
 Singular handler attachment points:
 To attach the same handler multiple times to process events that could be raised
from multiple elements.
 Example Code
 Class handling: Permit a static handler that is defined by the class.
 (the opportunity to handle an event before any attached instance handlers can.
 Referencing an event without reflection:
 Creates a RoutedEvent field as an identifier, which provides a robust event
identification technique that does not require static or run-time reflection.
How Routed Events Are Implemented
 // Register the routed event
public static readonly RoutedEvent SelectedEvent =
EventManager.RegisterRoutedEvent( "Selected",
RoutingStrategy.Bubble,
typeof(RoutedEventHandler),
typeof(MyCustomControl));

// .NET wrapper
public event RoutedEventHandler Selected{ add {
AddHandler(SelectedEvent, value); } remove {
RemoveHandler(SelectedEvent, value); }}

// Raise the routed event "selected“
RaiseEvent(new
RoutedEventArgs(MyCustomControl.SelectedEvent));
Routing Strategies:
 Bubbling:
 Event handlers on the event source are invoked.
 Then routes to successive parent elements until reaching the element tree root.
 To report input or state changes from distinct controls or other UI elements.
 Direct:
 Only the source element itself is given the opportunity to invoke handlers in
response.
 Analogous to the "routing" that Windows Forms uses for events.
 unlike a standard CLR event, direct routed events support class handling.
 Tunneling:
 Event handlers at the element tree root are invoked.
 Then The routed event then travels a route through successive child elements
along the route, towards the node element that is the routed event source.
 Compositing for a control, such that events from composite parts can be
deliberately suppressed or replaced by events that are specific to the complete
control.
 Input events provided in WPF often come implemented as a tunneling/bubbling
pair.
 Tunneling events are also sometimes referred to as Preview events, because of
a naming convention that is used for the pairs.
Resource
StaticResource:
 A simple way to reuse commonly defined objects and values.
 Provides a value for a XAML property by substituting the value of an already
defined resource.
Static resource lookup behavior
 For the requested key within the resource dictionary defined by the element
that sets the property.
 Traverses the logical tree upward, to the parent element and its resource
dictionary.
 Application resources
When:
 No intention of changing the value of the resource after it is referenced the
first time.
 Not reevaluated based on runtime behaviors such as reloading a page. So
some performance benefit.
 For Value of property that is not on a DependencyObject or a Freezable.
 Compiled into a DLL, and packaged as part of the application or shared
between applications
 Creating a theme for a custom control, and are defining resources that are
used within the themes.
DynamicResource
 Provides a value for a XAML property by deferring that value to be a
run-time reference to a resource.
When:
 The value of the resource depends on conditions that are not known
until runtime.
 Like SystemColors, SystemFonts, or SystemParameters
 Creating or referencing theme styles for a custom control.
 To adjust the contents of a ResourceDictionary during an application
lifetime.
 A forward reference may be required
 The resource might not be used immediately when the page loads.
 (Static resource references always load from XAML when the page
loads; however,
 a dynamic resource reference does not load until it is actually
used.)
 Applying resources to elements that might be reparented in the
logical tree during application lifetime.
Dynamic resource
 Dynamic resource lookup behavior
 Within the resource dictionary defined by the element that sets the
property.
 If the element defines a Style property, the Resources dictionary within
the Style is checked.
 If the element defines a Template property, the Resources dictionary
within the FrameworkTemplate is checked.
 Traverses the logical tree upward, to the parent element and its
resource dictionary.
 Application resources
 Theme resource dictionary
 System resources
 Merged Resource Dictionary
 A way to define the resources portion of a WPF application outside
of the compiled XAML application.
 (Resources can then be shared across applications)
Data Binding Overview
 The process that establishes a connection between the
application UI and business logic.
 Elements can be bound to data from a variety of data sources in
the form of common language runtime (CLR) objects and XML.
 Features:
 ContentControls such as Button and ItemsControls such as ListBox
and ListView have built-in functionality to enable flexible styling of
single data items or collections of data items.
 Sort, filter, and group views can be generated on top of the data.
 Basic Data Binding Concepts
Data Binding Overview
 Direction of the Data Flow
 What Triggers Source Updates
References:








http://msdn.microsoft.com
http://windowsclient.net
http://www.wpftutorial.net
http://joshsmithonwpf.wordpress.com
http://idealprogrammer.com
http://www.msdev.com
http://www.wpfdev.com
http://WPFpedia.com
A soft copy will be available at:
http://softarchitect.wordpress.com
For Future discussion, join
http://tech.groups.yahoo.com/group/SoftArchitect/
If you want to master a technology,
start teaching it to others.