WPF provides both Drawing and Shape objects to represent graph=
ical
drawing content. However, Drawing objects are simpler constructs tha=
n Shape
objects and provide better performance characteristics.
A Shape allows you to draw a graphical shape to the scr=
een.
Because they are derived from the FrameworkElement class, Shape
objects can be used inside panels and most controls.
WPF offers several layers of access to graphics and rendering
services. At the top layer, Shape objects are easy to use and provide
many useful features, such as layout and event handling. WPF provides a num=
ber
of ready-to-use shape objects. All shape objects inherit from the Shape<=
/b>
class. Available shape objects include Ellipse, Line, Path, Polygon, Polyli=
ne,
and Rectangle.
Drawing objects, on the other hand, do not derive from the Framewo=
rkElement
class and provide a lighter-weight implementation for rendering shapes, ima=
ges,
and text.
There are four types of Drawing objects:
· =
GeometryDrawing Draws a shape.
· =
ImageDrawing Draws an image.
· =
GlyphRunDrawing Draws text.
· =
DrawingGroup Draws other drawings. Use a drawing group to comb=
ine
other drawings into a single composite drawing.
The GeometryDrawing object is used to render geometry
content. The Geometry class and the concrete classes which derive from it, =
such
as CombinedGeometry, EllipseGeometry, and PathGeometry, provide a means for
rendering 2D graphics, as well as providing hit-testing and clipping suppor=
t.
Geometry objects can be used to define the region of a control, for example=
, or
to define the clip region to apply to an image. Geometry objects can be sim=
ple
regions, such as rectangles and circles, or composite regions created from =
two
or more geometry objects. More complex geometric regions can be created by
combining PathSegment-derived objects, such as ArcSegment, BezierSegment, a=
nd QuadraticBezierSegment.
On the surface, the Geometry class and the Shape
class are quite similar. Both are used in the rendering of 2D graphics and =
both
have similar concrete classes which derive from them, for example, Ellip=
seGeometry
and Ellipse. However, there are important differences between these =
two
sets of classes. For one, the Geometry class lacks some of the
functionality of the Shape class, such as the ability to draw itself=
. To
draw a geometry object, another class such as DrawingContext, Drawing, or a
Path (it is worth noting that a Path is a Shape) must be used to perform the
drawing operation. Rendering properties such as fill, stroke, and the stroke
thickness are on the class which draws the geometry object, while a shape o=
bject
contains these properties. One way to think of this difference is that a
geometry object defines a region, a circle for example, while a shape object
defines a region, defines how that region is filled and outlined, and
participates in the layout system.
Since Shape objects derive from the FrameworkElement=
class, using them can add significantly more memory consumption in your
application. If you really do not need the FrameworkElement features=
for
your graphical content, consider using the lighter-weight Drawing
objects.
For more information on Drawing objects, see ‘Dra=
wing
Objects Overview’ (topic available in the SDK).
The StreamGeometry object is a light-weight alternative to =
PathGeometry
for creating geometric shapes. Use a StreamGeometry when you need to
describe a complex geometry. StreamGeometry is optimized for handling
many PathGeometry objects and performs better when compared to using
many individual PathGeometry objects.
The following example uses attribute syntax to create a triang=
ular
StreamGeometry in XAML.
|
XAML
|
![3D"CopyCode](3D"OptimizingWPFApplicationPerformance_files/image008.gif") Copy Code<=
b>
|
|
<Page
xmlns=3D"http://schemas.microsoft.com/winfx/2006/xaml/presentation&qu=
ot;
&n=
bsp;
xmlns:x=3D"http://schemas.microsoft.com/winfx/2006/xaml"&=
gt;
&n=
bsp;
<StackPanel>
&n=
bsp;
&n=
bsp;
<Path Data=3D"=
;F0
M10,100 L100,100 100,50Z"
&n=
bsp;
StrokeThickness=3D"1" Stroke=3D"Black"/>
&n=
bsp;
&n=
bsp;
&n=
bsp;
</StackPanel>
&n=
bsp;
</Pa=
ge>
|
For more information on StreamGeometry objects, see =
216;How
to: Create a Shape Using a StreamGeometry’ (topic available in the SD=
K).
The DrawingVisual object is a lightweight drawing class that is
used to render shapes, images, or text. This class is considered lightweight
because it does not provide layout or event handling, which improves its
performance. For this reason, drawings are ideal for backgrounds and clip a=
rt.
For more information, see ‘Using DrawingVisual Objects’ (topic
available in the SDK).
WPF imaging provides a significant improvement over the imaging
capabilities in previous versions of Windows. Imaging capabilities, such as
displaying a bitmap or using an image on a common control were primarily
handled by the Microsoft Windows Graphics Device Interface (GDI) or Microso=
ft
Windows GDI+ application programming interface (API). These API provided
baseline imaging functionality, but lacked features such as support for cod=
ec
extensibility and high fidelity image support. WPF Imaging API have been
redesigned to overcome the shortcomings of GDI and GDI+ and provide a new s=
et
of API to display and use images within your applications.
When using images, consider the following recommendations for
gaining better performance:
· =
If your application requires you to display thumbnail images,
consider creating a reduced-sized version of the image. By default, WPF loa=
ds
your image and decodes it to its full size. If you only want a thumbnail
version of the image, WPF unnecessary decodes the image to its full-size and
then scales it down to a thumbnail size. To avoid this unnecessary overhead,
you can either request WPF to decode the image to a thumbnail size, or requ=
est
WPF to load a thumbnail size image.
· =
Always decode the image to desired size and not to the default
size. As mentioned above, request WPF to decode your image to a desired size
and not the default full size. You will reduce not only your application's
working set, but execution speed as well.
· =
If possible, combine the images into a single image, such as a
film strip composed of multiple images.
· =
For more information, see ‘Imaging Overview’ (topic
available in the SDK).
When animating the scale of any bitmap, the default high-quali=
ty
image re-sampling algorithm can sometimes consume sufficient system resourc=
es
to cause frame rate degradation, effectively causing animations to stutter.=
By
setting the BitmapScalingMode property of the RenderOptions object to LowQu=
ality
you can create a smoother animation when scaling a bitmap. LowQuality
mode tells the WPF rendering engine to switch from a quality-optimized
algorithm to a speed-optimized algorithm when processing images.=
The following example shows how to set the BitmapScalingMode f=
or
an image object.
|
C#
|
Copy Code<=
b>
|
|
// Set =
the
bitmap scaling mode for the image to render faster.
&n=
bsp;
RenderO=
ptions.SetBitmapScalingMode(MyImage,
BitmapScalingMode.LowQuality);
|
By default, WPF does not cache the rendered contents of TileBr=
ush
objects, such as DrawingBrush and VisualBrush. In static scenarios where
neither the contents nor use of the TileBrush in the scene is changi=
ng,
this makes sense, since it conserves video memory. It does not make as much
sense when a TileBrush with static content is used in a non-static
way—for example, when a static DrawingBrush or VisualBrush<=
/b>
is mapped to the surface of a rotating 3D object. The default behavior of W=
PF
is to re-render the entire content of the DrawingBrush or VisualB=
rush
for every frame, even though the content is unchanging.
By setting the CachingHint property of the RenderOptions
object to Cache you can increase performance by using cached versions of the
tiled brush objects.
The CacheInvalidationThresholdMinimum and CacheInvalidationThr=
esholdMaximum
property values are relative size values that determine when the TileBru=
sh
object should be regenerated due to changes in scale. For example, by setti=
ng
the CacheInvalidationThresholdMaximum property to 2.0, the cache for=
the
TileBrush only needs to be regenerated when its size exceeds twice t=
he
size of the current cache.
The following example shows how to use the caching hint option=
for
a DrawingBrush.
|
C#
|
Copy Code<=
b>
|
|
// Set =
the
minimum and maximum relative sizes for regenerating the tiled brush.<=
/o:p>
&n=
bsp;
RenderO=
ptions.SetCacheInvalidationThresholdMinimum(drawingBrush,
0.5);
&n=
bsp;
RenderO=
ptions.SetCacheInvalidationThresholdMaximum(drawingBrush,
2.0);
&n=
bsp;
&n=
bsp;
&n=
bsp;
// The =
tiled
brush will be regenerated when the size is
&n=
bsp;
// 0.5x, 0.25x (and so forth)<=
o:p>
&n=
bsp;
// and<=
o:p>
&n=
bsp;
// 2x, 4x, 8x (and so forth)
&n=
bsp;
// of t=
he
original size.
&n=
bsp;
&n=
bsp;
&n=
bsp;
// Set =
the
caching hint option for the brush.
&n=
bsp;
RenderO=
ptions.SetCachingHint(drawingBrush,
CachingHint.Cache);
|
Object
Behavior
Understanding the intrinsic behavior of WPF objects will help =
you
make the right tradeoffs between functionality and performance.<=
/span>
Not Removing Event
Handlers on Objects may Keep Objects Alive
The delegate that an object passes to its event is effectively=
a
reference to that object. Therefore, event handlers can keep objects alive
longer than expected. When performing clean up of an object that has regist=
ered
to listen to an object's event, it is essential to remove that delegate bef=
ore
releasing the object. Keeping unneeded objects alive increases the
application's memory usage. This is especially true when the object is the =
root
of a logical tree or a visual
tree.
WPF introduces a weak event listener pattern for events that c=
an
be useful in situations where the object lifetime relationships between sou=
rce
and listener are difficult to keep track of. Some existing WPF events use t=
his
pattern. If you are implementing objects with custom events, this pattern m=
ay
be of use to you. For details, see WeakEvent Patterns.
There are several tools, such as the CLR Profiler and the Work=
ing
Set Viewer, that can provides information on the memory usage of a specified
process. The CLR Profiler includes a number of very useful views of the
allocation profile, including a histogram of allocated types, allocation and
call graphs, a time line showing garbage collections of various generations=
and
the resulting state of the managed heap after those collections, and a call
tree showing per-method allocations and assembly loads. For more informatio=
n,
see Microsoft .NET Framework Developer Center.=
The Working Set Viewer is a WPF performance analysis tool that
provides information on the memory usage of a specified process. This tool
allows you to generate a snapshot of application memory usage information a=
t a
particular application state. For more information on WPF performance tools,
see ‘Performance Profiling Tools for WPF’ (topic available in t=
he
SDK).
In general, accessing a dependency property of a DependencyObj=
ect
is not slower than accessing a CLR property. While there is a small perform=
ance
overhead for setting a property value, getting a value is as fast as getting
the value from a CLR property. Offsetting the small performance overhead is=
the
fact that dependency properties support robust features, such as data bindi=
ng,
animation, inheritance, and styling. For more information, see ‘Depen=
dency
Properties Overview’ (topic available in the SDK).<=
/p>
You should define dependency properties in your application ve=
ry
carefully. If your DependencyProperty affects only render type metadata
options, rather than other metadata options such as AffectsMeasure, you sho=
uld
mark it as such by overriding its metadata. For more information about over=
riding
or obtaining property metadata, see Dependency Property Metadata.
It may be more efficient to have a property change handler
invalidate the measure, arrange, and render passes manually if not all prop=
erty
changes actually affect measure, arrange, and render. For instance, you mig=
ht
decide to re-render a background only when a value is greater than a set li=
mit.
In this case, your property change handler would only invalidate render when
the value exceeds the set limit.
By default, registered dependency properties are non-inheritab=
le.
However, you can explicitly make any property inheritable. While this is a
useful feature, converting a property to be inheritable impacts performance=
by
increasing the length of time for property invalidation.<=
/p>
While calling RegisterClassHandler allows you to save your
instance state, it is important to be aware that the handler is called on e=
very
instance, which can cause performance problems. Only use RegisterClassHa=
ndler
when your application requires that you save your instance state.
When creating a DependencyProperty that requires a defa=
ult
value, set the value using the default metadata passed as a parameter to th=
e Register
method of the DependencyProperty. Use this technique rather than set=
ting
the property value in a constructor or on each instance of an element.=
When creating a DependencyProperty, you have the option=
of
setting the PropertyMetadata using either the Register or OverrideMe=
tadata
methods. Although your object could have a static constructor to call Ov=
errideMetadata,
this is not the optimal solution and will impact performance. For best
performance, set the PropertyMetadata during the call to Register=
.
![](3D"OptimizingWPFApplicationPerformance_files/image002.gif")
![3D"DropDown](3D"OptimizingWPFApplicationPerformance_files/image004.jpg")
![3D"DropDownHover](3D"OptimizingWPFApplicationPerformance_files/image006.jpg")
![3D"CopyHover](3D"OptimizingWPFApplicationPerformance_files/image010.gif")
![](3D"OptimizingWPFApplicationPerformance_files/image012.gif")
![3DNote](3D"OptimizingWPFApplicationPerformance_files/image014.gif")
![3D"Hyperlinks](3D"OptimizingWPFApplicationPerformance_files/image016.jpg")
![3D"Visual](3D"OptimizingWPFApplicationPerformance_files/image018.jpg")
![3D"Visual](3D"OptimizingWPFApplicationPerformance_files/image020.jpg")
![3D"Property](3D"OptimizingWPFApplicationPerformance_files/image022.jpg")
![3D"Foote=](3D"OptimizingWPFApplicationPerformance_files/image024.jpg")