Windows Presentation Foundation Cookbook | Packt.Editorial Reviews

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
WebMay 19,  · PDF Download Windows Presentation Foundation Cookbook, by Pavel Yosifovich Whatever your condition, analysis will certainly always offer you easy . WebSep 24,  · Windows Presentation Foundation Cookbook: Author: Pavel Yosifovich: Publisher: Packt Publishing: Category: Applications & Software: Released . WebIf you came here in hopes of downloading Windows Presentation Foundation Cookbook from our website, you’ll be happy to find out that we have it in txt, DjVu, . WebOct 25,  · Microsoft\’s Windows Presentation Foundation (WPF) provides you with a development framework for building high-quality user experiences for the Windows .
 
 

Download PDF – Windows Presentation Foundation Cookbook [PDF] [kqltble40].Windows presentation foundation 4.5 cookbook code download

 

Explore Documents. Enjoy millions of ebooks, audiobooks, magazines, and more, with a free trial. Ebook 1, pages 6 hours. Start your free days. Read preview. About this ebook This book is written in an easy-to-read style, with a strong emphasis on real-world, practical examples. Step-by-step explanations are provided for performing important tasks.

If you are C developer looking forward to increasing your understanding and knowledge of WPF, then this is the best guide for you. Basic experience with Visual Studio is mandatory, as well as good C skills. Previous experience with Windows Forms is not required. Language English. Publisher Packt Publishing. Release date Sep 25, ISBN Related to Windows Presentation Foundation 4. Code like a Pro in C. Save Code like a Pro in C for later.

Mastering F. Save Mastering F for later. Functional C. Ebook Functional C by Anggoro Wisnu. Save Functional C for later. NET Design Patterns. NET Design Patterns for later. Writing High-Performance. NET Code, 2nd Edition. Ebook Writing High-Performance. Save Writing High-Performance. NET Code, 2nd Edition for later. Mastering Windows Presentation Foundation. Save Mastering Windows Presentation Foundation for later.

Windows Application Development Cookbook. Save Windows Application Development Cookbook for later. NET High-performance Programming. Ebook Learning. Save Learning. NET High-performance Programming for later. PowerShell and WMI. Windows PowerShell in Action. Save Windows PowerShell in Action for later. Mastering C 8. Ebook Mastering C 8. Save Mastering C 8. LINQ Quickly. Net Framework 4. Docker Bootcamp. Ebook Docker Bootcamp by Jeeva S. Save Docker Bootcamp for later.

Learning Python Network Programming. Faruque Sarker. Save Learning Python Network Programming for later. Docker Cookbook. Ebook Docker Cookbook by Neependra Khare. Save Docker Cookbook for later. NET Core for later. Mastering Python Regular Expressions. Save Mastering Python Regular Expressions for later. Developing with Docker.

Save Developing with Docker for later. Learning Docker. Ebook Learning Docker by Jeeva S. Save Learning Docker for later. Python High Performance Programming. Save Python High Performance Programming for later. PowerShell in Depth. Save PowerShell in Depth for later. Ebook C 7 and. Save C 7 and. Related podcast episodes.

Technado, Ep. Podcast Episode Technado, Ep. Save Technado, Ep. Heart of the Forest Review. Save Heart of the Forest Review for later. Podcast Episode Episode Save Episode Podcast Episode Testing and JUnit 5 with Marcel Schnelle: Marcel Schnelle joins Donn in this episode to talk about how to get your application under test and some steps to go from scared to confident in your testing process.

Save Testing and JUnit 5 with Marcel Schnelle: Marcel Schnelle joins Donn in this episode to talk about how to get your application under test and some steps to go from scared to confident in your testing process. JUnit 5 for later. Podcast Episode Episode It\’s gr8! Save Episode It\’s gr8! Save SE4 – How to make sense of the testing landscape Sergei Egorov : Don\’t let testing test your patience for later. Podcast Episode 2. Save 2. Full Show Notes: Follow us on Twitter: for later.

Podcast Episode Microsoft open-sources tool to stop AI from being hacked. Save Microsoft open-sources tool to stop AI from being hacked.

Also, listen to the profile of startup MicroAcquire for later. Related articles. Prizes from Affinity. Prizes from Affinity for later. This Month. How To. Share Your Mind-maps. Who We Are. Get The Look. What We Think. Tech Spotlight. Find Visually Similar Images. The Benefits Of Sync. Quick Tip. Help Station. Monitor And Improve Windows Startup. On Sale Weds 19 Jan. Warning: Junk Ahead. Tech Triumphs and Tragedies.

Dark Magic. Six Of The Best…. Essential Apps. Maps Collections. Music Servers. From the Editor. In Brief. Related categories Skip carousel. Reviews for Windows Presentation Foundation 4. What did you think? Rate as 1 out of 5, 1 stars. Right-click the project node, and select Add Class…. Name the class RandomExtension and click on Add. This markup extension will generate a random number in a given range. Add a using statement to System. This is how the class should look right now:.

We need to implement the ProvideValue method. The easiest way to get the basic prototype is to place the caret over MarkupExtension and use the smart tag again, this time selecting Implement abstract class. This is the result:. Now we must implement ProvideValue.

This should be the return value of the markup extension — a random number in the range provided by the constructors. Let\’s create a simple implementation:. Let\’s test this. The second TextBlock shows the generated random value. A markup extension is a class inheriting from MarkupExtension , providing some service that cannot be done with a simple property setter.

Such a class needs to implement one method: ProvideValue. Whatever is returned provides the value for the property. ProvideValue accepts an IServiceProvider interface that allows getting some \”context\” around the markup extension execution. In our simple example, it wasn\’t used. Any required arguments are passed via constructor s. Any optional arguments can be passed by using public properties as the next section demonstrates. We hit an exception.

The reason is that our ProvideValue returns a double , but the Text property expects a string. We need to make it a bit more flexible. We can query for the expected type and act accordingly. This is one such service provided through IServiceProvider :. You\’ll need to add a reference for the WindowsBase assembly where DependencyProperty is defined. IServiceProvider is a standard. NET interface that is a kind of \”gateway\” to other interfaces. Here we\’re using IProvideValueTarget , which enables discovering what property type is expected, with the TargetProperty property.

This is either a PropertyInfo for a regular CLR property or a DependencyProperty , so appropriate checks must be made before the final target type is ascertained. Once we know the type, we\’ll try to convert to it automatically using the Convert class, or return it as a string if that\’s not possible. Constructors are one way to get parameters for a markup extension. Properties are another, allowing optional values to be used if necessary.

For example, let\’s extend our random extension, so that it is able to provide fractional values and not just integral ones. This option would be set using a simple public property:. The implementation of ProvideValue should change slightly; specifically, calculation of the value variable:. Markup extensions are powerful. They allow arbitrary code to run in the midst of XAML processing.

We just need to remember that XAML is, and should remain, declarative. It\’s pretty easy to go overboard, crossing that fine line. Here\’s an example: let\’s extend our RandomExtension to allow modifying the property value at a regular interval.

First, a property to expose the capability:. This is the actual object on which the property is to be set. Events are essentially notifications from an object to the outside world — a variation on the \”observer\” design pattern. Most of the time an object is told what to do via properties and methods. Events are its way of talking back to whoever is interested. The concept of events existed in.

WPF introduces routed events, an enhanced infrastructure for raising and handling events, which we\’ll look at in this recipe. This will be a simple drawing program. Add some markup to MainWindows. Intellisense will pop up, suggesting to add a default handler name. Resist the temptation, and type OnMouseDown :. Visual Studio will add the required handler method in the code behind file MainWindow.

Let\’s add simple drawing logic. First, add the following fields to the MainWindow class:. If we\’re in drawing mode, we create a Line object, set its two points locations and add it to the Canvas. We now have a functional little drawing program. Event handling seemed to be as simple as expected. Let\’s make it a little more interesting, with the ability to change drawing color. We\’ll add some rectangle elements in the upper part of the canvas.

Clicking any of them should change the drawing brushing from that point on. First, the rectangles:. How should we handle clicks on the rectangles? One obvious way is to attach an event handler to each and every rectangle.

But that would we wasteful. Events such as MouseLeftButtonDown \”bubble up\” the visual tree and can be handled at any level. In this case, we\’ll just add code to the OnMouseDown method:. WPF events are called routed events because most can be handled by elements that are not the source of the event.

In the preceding example, the MouseLeftButtonDown was handled on the Canvas element, even though the actual event may have triggered on a particular Rectangle element. This is referred to as a routing strategy of bubbling. GetPosition method.

And finally, although not strictly required, we \”capture\” the mouse, so that subsequent events will be sent to the Canvas and not any other window, even if the mouse pointer technically is not over the Canvas.

To properly ascertain which element was actually the source of the event, the RoutedEventArgs. Source property should be used and not the sender , in our example the sender is always the Canvas. Bubbling is not the only routing strategy WPF supports. The opposite of bubbling is called tunneling ; events with a tunneling strategy are raised first on the top level element typically a Window , and then on its child, and so on, towards the element that is the actual source of the event.

After the tunneling event has finished calling any handlers along the way , its bubbling counterpart is raised, from the source up the visual tree towards the top level element window. A tunneling event always has its name starting with Preview. A third routing strategy is supported, called Direct. This is the simplest strategy; the event is raised on the source element of the event and that\’s it. No bubbling or tunnelling occurs.

After a bubbling event is handled by some element — it continues to bubble. The bubbling can be stopped by setting the RoutedEventArgs. Handled property to true. If the event is a tunneling one — setting Handled to true stops the tunneling, but it also prevents the buddy-bubbling event from ever firing.

This is a Grid that contains various Button controls. We would like to use as few handlers as we can. What about the digit buttons? Again, we could add a click handler to each one, but that would be wasteful. A better approach would be to leverage the Click event\’s bubbling strategy and set a single handler on the container Grid. Intellisense won\’t help and in fact this won\’t compile. It may be obvious — a Grid has no Click event.

Click is specific to buttons. Does this mean we can\’t set a Click handler on the Grid? Fortunately, we can. WPF provides the notion of attached events. Such events can be handled by any element, even if that element\’s type does not define any such event. This is achieved through attached event syntax similar to attached properties , such as the following code snippet:. The Click event is defined on the ButtonBase class , although Button. Click works just as well, because Button inherits from ButtonBase.

Now we can look at the actual source of the click with the same RoutedEventArgs. Source described previously:. You can find the complete calculator sample in the CH Calculator project, available with the downloadable source for this chapter. He writes, develops, consults, and trains developers on various software development topics, from Windows internals to.

NET enterprise systems, and almost everything in between. He\’s a Microsoft MVP and a frequent speaker at national events. In the past, he co-founded the startup company Quiksee that was acquired by Google in September About 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. Publication date: September Publisher Packt.

Pages ISBN Download code from GitHub. Chapter 1. A public default constructor Settable public properties. XAML and compilation. Dependency properties. Change notifications when the property\’s value is changed.

Validation handler called as part of a set operation. Property value inheritance down the visual tree if so desired. No memory is allocated for a property\’s value if that value is never changed from its default. Creating custom type instances in XAML. Getting ready.

How to do it CustomTypes\” Copy. How it works There\’s more MyOtherTypes\” ] Copy. Creating a dependency property. Property value inheritance. Inherits ; Copy. Why \”dependency\”? ClearValue TextBlock. FontSizeProperty ; Copy. Dependency property levels.

This book is it\’s well organized, and to the point. Data binding gets a passing mention with regard to UI elements but an in-depth treatment is missing. I write business apps and have a data model to bind to my UI. I need to bind objects and sets of objects, and I\’ve found most WPF books lacking in this area. Before this book, my best source was a book on writing Silverlight business applications poor, dead Silverlight! I actually bought this book because of a few recipes about business data model binding, but found so much more.

I started reading it from the beginning and learned something in every single solution. The author has a great style and explains things clearly. In our current tech world, where product documentation is basically crowd-sourced to third-party forum sites like Stack Exchange, it is often hard to find a source that presents a cohesive view of a product. Don\’t get me wrong, I love Stack Exchange and use it a lot, but the bigger picture can be lost in code snippets.

As this is a cookbook, there is lots of code to look at, but the surrounding text gives a great context for the problem being solved, and I learned some foundational pieces about WPF along the way.

Great book! Great book. The author explains things very well. I would have liked some more coverage of the MVVM pattern as this was the main reason I purchased the book. Having said that, there aren\’t many other books with good reviews that cover MVVM. There are some that are dedicated to MVVM but have bad reviews. I considered \”C 6. NET 4. Again, the other does a great job explaining things so check the online content page and the amount of coverage each topic gets.

Chapter Custom validation rules Chapter Custom error template Chapter Using data annotations Chapter 7. Chapter 8.

Chapter Style inheritance Chapter Other places to set styles Chapter Applying a style automatically Chapter Getting ready Chapter How to do it Chapter Custom behaviors Chapter Replacing the control template of a progress bar Chapter Getting ready Chapter How to do it Chapter What about the control\’s properties? Chapter Combining a control template with a style Chapter Extending a template with attached properties Chapter Can we replace just part of a template? Chapter What about the Visual State Manager?

Chapter Replacing the control template of a scroll bar Chapter Getting ready Chapter How to do it Chapter 9. Chapter Other uses for transforms Chapter Manipulating a bitmap programmatically Chapter Getting ready Chapter How to do it Chapter How about higher-level access to WriteableBitmap?

Chapter Creating property-based animations Chapter Getting ready Chapter How to do it Chapter Alternative way to specify the animation property Chapter More on storyboards Chapter Animations with Expression Blend Chapter Should I always use animations? Chapter Adding animation easing to animations Chapter Getting ready Chapter How to do it Chapter Using custom effects with pixel shaders Chapter Getting ready Chapter How to do it Chapter Using the built-in effects Chapter Other shader types Chapter What about the BitmapEffect class and its derivatives?

Chapter

 

replace.me: Windows Presentation Foundation Cookbook eBook : Yosifovich, Pavel: Kindle Store.Windows presentation foundation 4.5 cookbook code download

 

Step-by-step explanations are provided for performing important tasks. If you are C developer looking forward to increasing your understanding and knowledge of WPF, then this is the best guide for you. Basic experience with Visual Studio is mandatory, as well as good C skills. Previous experience with Windows Forms is not required. Pavel is a developer, trainer, author, and speaker. Pavel loves all things software and still sometimes misses his old Commodore Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.

Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness. Enhance your purchase. Full of illustrations, diagrams, and tips with clear step-by-step instructions and real world examples Gain a strong foundation of WPF features and patterns Leverage the MVVM pattern to build decoupled, maintainable apps In Detail 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.

What will you learn from this book Get tips and insights to maximize your productivity Learn to build complex and flexible user interfaces using XAML Perform lengthy operations asynchronously while keeping the UI responsive Get well-versed with WPF features such as data binding, layout, resources, templates, and styles Customize a control\’s template to alter appearance but preserve behaviour Approach This book is written in an easy-to-read style, with a strong emphasis on real-world, practical examples.

Who this book is written for If you are C developer looking forward to increasing your understanding and knowledge of WPF, then this is the best guide for you. Previous page. Packt Publishing. Publication date. September 25, Print length. See all details. Next page. About the Author Pavel Yosifovich Pavel Yosifovich is a software developer, trainer and consultant,specializing in Microsoft technologies and tools, from Windows internals, to.

NET enterprise systems, and almost everything in between. Brief content visible, double tap to read full content. Full content visible, double tap to read brief content. Help others learn more about this product by uploading a video! About the author Follow authors to get new release updates, plus improved recommendations. Pavel Yosifovich.

Read more Read less. Customer reviews. How customer reviews and ratings work Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them. Learn more how customers reviews work on Amazon. Top reviews Most recent Top reviews. Top reviews from the United States. There was a problem filtering reviews right now. Please try again later. Verified Purchase. My initial assessment is that this is a really good book on Windows programming.

I have read a few other books on Windows programming front-to-back this past year and was starting to think I might be losing interest in programming. I like the cookbook format in that it describes a problem and then shows the solution. What I like best about Pavel Yosifovich\’s book so far is that he packs useful information about Windows programming in almost every sentence, even information about Windows programming that has nothing to do with the book\’s topic. I wanted to write this review today for a different reason than recommending this book, though.

The resources of net link could also be enjoyed in several locations. As one of the advantages is to get the online book, as the world home window, as lots of people suggest. When a necessary of reviewing grows better, it\’s the moment to pick the new publication, when the very best publication on the planet for any age is given, you could take it as soon as possible. It will not need to await long time once more.

Getting this book quicker after reading this passage is actually smart. You could see how the Windows Presentation Foundation 4. From the book, you will certainly realize that analysis is absolutely needed to do. It will certainly guide you to obtain more precious spending quality time. By reading guides, your hung out will certainly not squander inaccurately. You could find just what you want and needs to observe. Below, the Windows Presentation Foundation 4.

Even it is only the rep are for getting this sort of book, you may see how you could delight in the book specifically. The options of the words, dictions, and also just how the writer shares the message and also lesson to the readers are extremely easy to understand. So, when you really feel bad, you could not believe so difficult concerning this publication.

You can delight in and also take several of the lesson offers. The daily language use makes the Windows Presentation Foundation 4. You can discover the means of you to make correct declaration of reviewing design. Well, it\’s not a very easy difficult if you really do not like reading. It will be worse. However, this publication will direct you to really feel various of what you could really feel so.

Pavel Yosifovich Pavel Yosifovich is a software developer, trainer and consultant,specializing in Microsoft technologies and tools, from Windows internals, to. NET enterprise systems, and almost everything in between. These are pretty much the only books out there I have to say this book is the best of them all.

I haven\’t written any reviews for the other books only this one. That\’s how much i like this book. Trust me if you\’re new to WPF this book is the best one. Let\’s add a Rectangle element to the Canvas and place it in some position:.

The Canvas. Left and Canvas. Top are attached properties. They are defined by the Canvas type, but they can be applied to any element technically, anything that derives from DependencyObject. In this case, these two properties are applied to the Rectangle , essentially \”extending\” its property set with two new properties.

The syntax DefiningClassName. Now let\’s try changing these properties in code. When the repeat button is clicked, let\’s move the rectangle a little bit to the right. First, let\’s name the Rectangle , so we can easily refer to it in code:. Add a Click event handler to the RepeatButton. In the handler, add the following code:. An attached property is accessed in code using a set of static methods on the class declaring the property in this case, the Canvas.

The first argument to these methods is the intended target of the property in this case the Rectangle. Click on the button and hold ; you should see the rectangle moving along to the right, 5 units at a time. An attached property is first and foremost a dependency property, meaning it supports all the capabilities of dependency properties. However, as an attached property is \”attached\” to an object that did not define it, a simple property like syntax is not possible — as C does not support the concept of attached properties natively.

Instead, the declaring class provides two static methods, named DeclaringType. SetPropertyName and DeclaringType. GetPropertyName , that provide a way to set or get the property value for some object passed in as the first argument as demonstrated in the last code snippet. PropertyName attribute to the aforementioned Set method. This means that the code to move the rectangle could have been written as follows:.

One may wonder why to go to all this trouble for the Left and Top properties. Would it not be simpler to define the Left and Top properties on the for example UIElement class and be done with it? These properties could have been normal dependency properties and enjoy the simpler syntax they carry. The reason is, that a Left or Top property may not always make sense. In fact, it only makes sense when the element is placed within a Canvas. What if the rectangle is inside a Grid?

Or a StackPanel? This leads to the conclusion that attached properties are a kind of contextual property — they are relevant under particular circumstances, so they can be \”attached\” if and when actually needed.

The previous example may lead to a wrong conclusion. It seems Canvas. Left and the like are only relevant when the element is inside a Canvas.

Similarly, the Grid. Row and Grid. Column attached properties only make sense for elements placed inside a Grid. Is this somehow necessary from an attached property point of view? Not at all. This is just coincidence.

The above properties in fact make sense only for elements placed inside their respective declaring type, but that does not have to be the case.

For example, suppose we have a button with a tool tip defined:. If the button is disabled IsEnabled set to true , the tool tip does not appear at runtime. To make it appear even if the control is disabled, we must set the ToolTipService.

ShowOnDisabled attached property to true :. We set the property on the button, but it\’s defined in the ToolTipService class. This class is not an element unlike the Canvas for example. In fact, it\’s a static class instances of it cannot be created. The way this connection is established so it can have some effect will be revealed in the next recipe in this chapter. To create your own attached properties, refer to the next recipe, Creating an attached property. An attached property can be used to somehow \”enhance\” or extend another object.

In the case outlined in the previous recipe, Using an attached property , an element was placed at exact coordinates within a Canvas using the attached Canvas. Top properties. An attached property is a powerful tool for extending the behavior of any object without the need to inherit from the type of the object.

In this task, we\’ll see this in action. Open MainWindow. Add some elements in a Canvas replace the default Grid as follows:.

Suppose we want to rotate a particular element around its center. We would have to write something like this example for the Ellipse :. Although this is certainly possible, this makes for a lot of typing. Now imagine doing something similar for other elements. Let\’s make it shorter by defining and using an attached property. We\’ll register a new attached property within this class; a property any other object can use. To do that, we\’ll take advantage of a Visual Studio code snippet, propa similar in concept to propdp discussed in the task Creating a dependency property in this chapter.

Inside the class definition, type propa without the quotes. This is how it should look at this point:. Press Tab once, and fill in the property details as follows: the property type should be double, its name should be Angle , its owner class RotationManager , and its default value zero. You\’ll have to add a using statement for System.

Windows namespace. The generated code should look as follows after removing the comment and some formatting :. Now that we have an attached property definition, let\’s use it. We\’ll set it on our various elements. Now let\’s set the property with various values on the various elements.

Here\’s an example for the Ellipse notice the intellisense popping up to help :. Add similar settings for the Rectangle and Button like as follows:. Notice that the designer preview shows no change. If you run the application, nothing happens. And why would anything happen? We declared a property and nothing else. Let\’s add some behavior logic if the property is actually used.

For that, we\’ll add a property changed handler notification. Go back to RotationManager. The OnAngleChanged method will be called for any change in the property value on any object it\’s applied to. Let\’s add some simple logic that will rotate the element:. If we switch back to the designer, we\’ll see the elements rotated according to the specified angles.

If we run the application, we\’ll see something like this:. Attached properties are registered similarly to regular dependency properties. In terms of functionality, they are dependency properties. This means they support everything a dependency property supports: data binding, animation, and so on. An attached property can be defined by any class RotationManager in our example and can be applied to any object whose type derives from DependencyObject.

Simply registering an attached property has no effect on its own. There must be some \”extra\” code that looks for that property and does something when it\’s applied or changed. In the example shown, this is done by specifying a property changed handler, called by WPF whenever the property is changed on any object. This also shows the weakness of attached properties: it\’s not possible to know whether specifying the property on some object is beneficial.

We could have thrown an exception if the object was not UIElement -derived to somewhat rectify this albeit at runtime rather than compile time , but this is not typically employed although we could have written something with Debug.

WriteLine to indicate this needs attention , as there may be other code that does not consider this an invalid setting. The property change notification scheme is typically used by WPF with attached properties that are defined by panels, such as Canvas , DockPanel , and Grid. Note that the panels only look for the relevant attached properties on their immediate children and not grandchildren.

This is not a limitation of attached properties, it\’s simply the way these panels work. Although attached properties within panels are common, there are other ways these properties can be used. One possibility is to use the existence of these property values within styles a complete treatment of styles is in given Chapter 8 or templates templates are discussed in Chapter 6 and Chapter 8. For now, think of a style as a grouping of related settings that can be applied as a group to an element.

For example, the following style accomplishes roughly the same thing as our property change handler:. Of course, this example works with buttons only because of the targeted style style that works on buttons only , but the result is the same. Note the parentheses around the attached property name.

This is essential — otherwise the XAML parser does not understand this to be an attached property; it interprets local:RotationManager as the property name and expects Angle to be a sub-property. An attached property is paradoxically a detached entity. It has no special affinity to the declaring type. This means we can use an already defined attached property if it\’s typed appropriately, named appropriately, and has no use in the needed situation. In our example, we need an attached property that is of type double , has an intuitive enough name maybe something with \”angle\” or \”rotate\” , and is unused in scenarios where the use of our property makes sense.

Clearly, it\’s not easy finding such a property, but sometimes one may get lucky. For instance, if we elect to go for the attached property ToolTipService. HorizontalOffset typed as double , we can achieve the same effect as previously with a style setter without defining a new attached property. This is not a good choice in this case, as an offset is not an angle, and clearly tooltips have nothing to do with rotation.

The worse problem here is that there may be a legitimate reason to place that property on a button to cater offsetting a tooltip , so that reusing for rotation purposes would collide with the tooltip, making only one a winner. Still, the general concept holds — any attached property can be reused. Attached property reuse is possible in styles, templates data template and control template , and triggers within styles and templates.

For background on dependency properties, check out the recipe Creating a dependency property in this chapter. XAML provides an easy way to set values of properties—type converters and the extended property syntax allow for flexible setting of values. However, some things cannot be expressed as a simple value, such as setting a property to the value of some static property. Replace the Grid element with a StackPanel. Suppose we want to fill the ellipse with the desktop color selected by the user in Windows.

WPF provides the SystemColors class, with many static properties that return a Brush representing the user\’s choice. For the desktop, this is a DesktopBrush property. We can try the following:. This throws an exception at runtime, as it cannot be converted to any \”known\” color such as Red or Blue. This works. You can verify this by going to Control Panel , then selecting Personalization on Windows 7 or 8.

Select Window Color switch to the classic theme first if the following window is shown differently. The Window Color and Appearance dialog is displayed:.

Change the desktop color and run the application again. You should see the ellipse filled with the new color. In this case, the active caption color on my system is a gradient, so the ActiveCaptionBrush provides the left side. The right side is provided by the GradientActiveCaptionBrush property. They are both brushes. If we wanted to recreate the caption gradient within the rectangle, we would need color objects, not brushes.

Let\’s combine these in a LinearGradientBrush :. XAML basically has very few capabilities. It can create objects, set values for properties, and set up event handlers. This is intentional, as XAML is declarative in nature. It cannot, for instance, call methods. That would make it closer to an imperative language such as C , which would make its existence dubious at best.

Sometimes, however, declarative operations require more than setting up properties. A method may be involved, or some other unusual construct, but the intent may still be declarative. This is where markup extensions come in. They provide a way to extend XAML with new hopefully declarative capabilities. A markup extension is a class that derives from System. MarkupExtension and implements a single method, ProvideValue. StaticExtension class. In fact, most markup extensions end with \”Extension\” a notable exception is the Binding markup extension.

Markup extensions are used to extend the capabilities of XAML, by providing declarative operations that need more than just setting some properties. These can be used to do pretty much anything, so caution is advised — these extensions must preserve the declarative nature of XAML, so that non-declarative operations are avoided; these should be handled by normal C code.

We\’ll create a new markup extension that would provide random numbers and use it within a simple application:. First, we\’ll create a class library with the markup extension implementation and then test it in a normal WPF application. Create a new Class Library project named CH Make sure the checkbox Create directory for solution is checked, and click on OK :.

The base MarkupExtension class resides in the System. Xaml assembly. Add a reference to that assembly by right-clicking the References node in the Solution Explorer , and selecting Add Reference…. Scroll down to System. Xaml and select it. Right-click the project node, and select Add Class….

Name the class RandomExtension and click on Add. This markup extension will generate a random number in a given range. Add a using statement to System.

This is how the class should look right now:. We need to implement the ProvideValue method. The easiest way to get the basic prototype is to place the caret over MarkupExtension and use the smart tag again, this time selecting Implement abstract class.

This is the result:. Now we must implement ProvideValue. This should be the return value of the markup extension — a random number in the range provided by the constructors.

Let\’s create a simple implementation:. Let\’s test this. The second TextBlock shows the generated random value. A markup extension is a class inheriting from MarkupExtension , providing some service that cannot be done with a simple property setter.

Such a class needs to implement one method: ProvideValue. Whatever is returned provides the value for the property. ProvideValue accepts an IServiceProvider interface that allows getting some \”context\” around the markup extension execution.

In our simple example, it wasn\’t used. Any required arguments are passed via constructor s. Any optional arguments can be passed by using public properties as the next section demonstrates.

We hit an exception.