c# : winform : pdf viewer : Adding a page to a pdf in preview control SDK system web page .net asp.net console Pro_Silverlight_5_in_CSharp_4th_edition77-part145

CHAPTER 21  DATA CONTROLS 
770 
 What’s New  Silverlight 5 adds a new version of the PivotViewer control to the core framework. Previously, the 
PivotViewer was available only through the Silverlight Control Toolkit, and its programming model was subtly 
different. To get up to speed, check out the section named “The PivotViewer” toward the end of this chapter. 
Better Data Forms 
In the previous chapter, you learned how to use data binding to build basic data forms. These forms—
essentially, ordinary pages made up of text boxes and other bound controls—allow users to enter, edit, 
and review data. Best of all, they require relatively little code. 
But the reality isn’t as perfect as it seems. To build a data form, you need a fair bit of handwritten 
XAML markup, which must include hard-coded details such as caption text, prompts, and error 
messages. Managing all these details can be a significant headache, especially if the data model changes 
frequently. Change the database, and you’ll be forced to alter your data classes and your user interface—
and Visual Studio’s compile-time error checking can’t catch invalid bindings or outdated validation 
rules. 
For these reasons, the creators of Silverlight are hard at work building higher-level data controls, 
helper classes, and even a whole server-based data-management framework (the forthcoming RIA 
Services). And although these features are still evolving rapidly, some components have already trickled 
down into the Silverlight platform. In the following sections, you’ll see how three of them—the Label, 
DescriptionViewer, and ValidationSummary—can make it easier to build rich data forms right now, 
particularly when you combine them with the powerful data annotations feature. 
 Note  To get access to the Label, DescriptionViewer, and ValidationSummary controls, you must add a reference 
to the System.Windows.Controls.Data.Input.dll assembly. If you add one of these controls from the Toolbox, Visual 
Studio will add the assembly reference and map the namespace like this: 
xmlns:dataInput="clr-
The Goal: Data Class Markup 
Although you can use Label, DescriptionViewer, and ValidationSummary on their own, their greatest 
advantages appear when you use them with smart data classes—classes that use a small set of attributes 
to embed extra information. These attributes allow you to move data-related details (such as property 
descriptions and validation rules) into your data classes rather than force you to include them in the 
page markup. 
The attribute-based approach has several benefits. First, it’s an impressive time-saver that lets you 
build data forms faster. Second, and more important, it makes your application far more maintainable 
because you can keep data details properly synchronized. For example, if the underlying data model 
changes and you need to revise your data classes, you simply need to tweak the attributes. This is 
quicker and more reliable than attempting to track down the descriptive text and validation logic that’s 
scattered through multiple pages—especially considering that the data class code is usually compiled in 
a separate project (and possibly managed by a different developer). 
www.it-ebooks.info
Adding a page to a pdf in preview - insert pages into PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide C# Users to Insert (Empty) PDF Page or Pages from a Supported File Format
add page numbers to a pdf file; adding page numbers to a pdf file
Adding a page to a pdf in preview - VB.NET PDF Page Insert Library: insert pages into PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Easy to Use VB.NET APIs to Add a New Blank Page to PDF Document
add page numbers to pdf using preview; add page number pdf file
CHAPTER 21  DATA CONTROLS 
771 
 Note  The attribute-based approach also has a drawback when you’re using web services. Because all the 
attributes are placed on the data class, they’ll be stripped out of the automatically generated client-side code. To 
avoid this problem, you need to use web service type sharing, which lets you share the same class definition 
between the server-side ASP.NET code and the client-side Silverlight code. Chapter 19 describes how to use this 
technique, and the downloadable code for this chapter puts it into practice. 
In the following sections, you’ll see how the data attributes works. Using them, you’ll learn how you 
can embed captions, descriptions, and validation rules directly in your data objects. 
The Label  
The Label takes the place of the TextBlock that captions your data controls. For example, consider this 
markup, which displays the text “Model Number” followed by the text box that holds the model number: 
<TextBlock Margin="7">Model Number:</TextBlock
<TextBox Margin="5" Grid.Column="1" x:Name="txtModelNumber" 
Text="{Binding ModelNumberMode=TwoWay}"></TextBox
You can replace the TextBlock using a label like this: 
<dataInput:Label Margin="7" Content="Model Number:"></dataInput:Label
<TextBox Margin="5" Grid.Column="1" x:Name="txtModelNumber" 
Text="{Binding ModelNumberMode=TwoWay}"></TextBox
Used in this way, the label confers no advantage. Its real benefits appear when you use binding to 
latch it onto the control you’re captioning using the Target property, like this: 
<dataInput:Label Margin="7" Target="{Binding ElementName=txtModelNumber}"> 
</dataInput:Label
<TextBox Margin="5" Grid.Column="1" x:Name="txtModelNumber" 
Text="{Binding ModelNumberMode=TwoWay}"></TextBox
When used this way, the label does something interesting. Rather than rely on you to supply it with 
a fixed piece of text, it examines the referenced element, finds the bound property, and looks for a 
Display attribute like this one: 
[Display(Name="Model Number")] 
public string ModelNumber 
{ ... } 
The label then displays that text—in this case, the cleanly separated two-word caption “Model 
Number.” 
www.it-ebooks.info
C# PDF insert image Library: insert images into PDF in C#.net, ASP
digital photo, scanned signature or logo into PDF document page in C# solve this technical problem, we provide this C#.NET PDF image adding control, XDoc
adding a page to a pdf; add page numbers to a pdf document
C# PDF insert text Library: insert text into PDF content in C#.net
Insert formatted text and plain text to PDF page using .NET XDoc.PDF component in C#.NET class. Supports adding text to PDF in preview without adobe reader
add page numbers to pdf in preview; adding page numbers in pdf file
CHAPTER 21  DATA CONTROLS 
772 
 Note  Before you can add the Display attribute to your data class, you need to add a reference to the 
System.ComponentModel.DataAnnotations.dll assembly. (You also need to import the 
System.Compon
From a pure markup perspective, the label doesn’t save any keystrokes. You may feel that it takes 
more effort to write the binding expression that connects the label than it does to fill the TextBlock with 
the same text. However, the label approach has several advantages. Most obviously, it’s highly 
maintainable—if you change the data class at any time, the new caption will flow seamlessly into any 
data forms that use the data class, with no need to edit a line of markup. 
The label isn’t limited to displaying a basic caption. It also varies its appearance to flag required 
properties and validation errors. To designate a required property (a property that must be supplied in 
order for the data object to be valid), add the Required attribute: 
[Required()] 
[Display(Name="Model Number")] 
public string ModelNumber 
{ ... } 
By default, the label responds by bolding the caption text. But you can change this formatting—or 
even add an animated effect—by modifying the Required and NotRequired visual states in the label’s 
control template. (To review control templates and visual states, refer to Chapter 15.) 
Similarly, the label pays attentions to errors that occur when the user edits the data. For this to work, 
your binding must opt in to validation using the ValidatesOnExceptions and NotifyOnValidationError 
properties, as shown here with the UnitCost property: 
<dataInput:Label Margin="7" Grid.Row="2" 
Target="{Binding ElementName=txtUnitCost}"></dataInput:Label> 
<TextBox Margin="5" Grid.Row="2" Grid.Column="1" x:Name="txtUnitCost" Width="100" 
HorizontalAlignment="Left" Text="{Binding UnitCostMode=TwoWay, ValidatesOnExceptions=true, 
NotifyOnValidationError=true}"></TextBox> 
To test this, type non-numeric characters into the UnitCost field, and tab away. The caption text in 
the label shifts from black to red (see Figure 21-1). If you want something more interesting, you can 
change the control template for the label—this time, you need to modify the Valid and Invalid visual 
states. 
www.it-ebooks.info
VB.NET PDF insert text library: insert text into PDF content in vb
Studio .NET PDF SDK library supports adding text content to Add text to certain position of PDF page in Visual Add text to PDF in preview without adobe reader
add pdf pages to word; add page numbers pdf file
C# Create PDF Library SDK to convert PDF from other file formats
What's more, you can also protect created PDF file by adding digital signature (watermark) on PDF Create a new PDF Document with one Blank Page in C#
adding page numbers in pdf; add a page to a pdf in acrobat
CHAPTER 21  DATA CONTROLS 
773 
Figure 21-1. A required ModelNumber and invalid UnitCost 
 Note  The error notification in the label is in addition to the standard error indicator in the input control. For 
example, in the page shown on Figure 21-1, the UnitCost text box shows a red outline and red triangle in the 
upper-right corner to indicate that the data it contains is invalid. In addition, when the UnitCost text box gets the 
focus, a red balloon pops up with the error description.  
The DescriptionViewer  
The Label control takes care of displaying caption text, and it adds the ability to highlight required 
properties and invalid data. However, when users are filling out complex forms, they sometimes need a 
little more. A few words of descriptive text can work wonders, and the DescriptionViewer control gives 
you a way to easily incorporate this sort of guidance into your user interface. 
It all starts with the Display attribute you saw in the previous section. Along with the Name 
property, it accepts a Description property that’s intended for a sentence or two or more detailed 
information: 
[Display(Name="Model Number"
Description="This is the alphanumeric product tag used in the warehouse.")] 
public string ModelNumber 
{ ... } 
Here’s the markup that adds a DescriptionViewer to a column beside the ModelNumber text box: 
<TextBlock Margin="7">Model Number</TextBlock> 
www.it-ebooks.info
C# Word - Insert Blank Word Page in C#.NET
This C# .NET Word document page inserting & adding component from RasterEdge is written in managed C# code and designed particularly for .NET class applications
add page numbers pdf; add a page to a pdf online
C# PowerPoint - Insert Blank PowerPoint Page in C#.NET
This C# .NET PowerPoint document page inserting & adding component from RasterEdge is written in managed C# code and designed particularly for .NET class
adding page numbers to a pdf in preview; add remove pages from pdf
CHAPTER 21  DATA CONTROLS 
774 
<TextBox Margin="5" Grid.Column="1" x:Name="txtModelNumber" 
Text="{Binding ModelNumberMode=TwoWay, ValidatesOnExceptions=true, 
NotifyOnValidationError=true}"></TextBox> 
<dataInput:DescriptionViewer Grid.Column="2"  
Target="{Binding ElementName=txtModelNumber}"></dataInput:DescriptionViewer> 
The DescriptionViewer shows a small information icon. When the user moves the mouse over it, the 
description text appears in a tooltip (Figure 21-2). 
Figure 21-2. The DescriptionViewer 
You can replace the icon with something different by setting the GlyphTemplate property, which 
determines the display content of the DescriptionViewer. Here’s an example that swaps in a new icon: 
<dataInput:DescriptionViewer Grid.Row="1" Grid.Column="2" 
Target="{Binding ElementName=ModelName}">             
<dataInput:DescriptionViewer.GlyphTemplate> 
<ControlTemplate> 
<Image Source="info.jpg" Stretch="None"></Image> 
</ControlTemplate> 
</dataInput:DescriptionViewer.GlyphTemplate> 
</dataInput:DescriptionViewer> 
The DescriptionViewer doesn’t change its appearance when the bound data has a validation error. 
However, it does include an IsValid property, and it does support the four basic visual states for 
validation (ValidFocused, ValidUnfocused, InvalidFocused, and InvalidUnfocused). That means you can 
change the DescriptionViewer template and add some sort of differentiator that changes its appearance 
to highlight errors or applies a steady-state animation. 
www.it-ebooks.info
C# PowerPoint - How to Process PowerPoint
& Insert PowerPoint Page/Slide in C#. Use the provided easy to call and write APIs programmed in C# class to develop user-defined PowerPoint slide adding and
add page break to pdf; add pages to pdf preview
C# TIFF: TIFF Editor SDK to Read & Manipulate TIFF File Using C#.
1. Support embedding, removing, adding and updating ICCProfile. 2. Render text to text, PDF, or Word file. You will see the following aspects on this guide page.
add page number to pdf online; add pages to pdf document
CHAPTER 21  DATA CONTROLS 
775 
The ValidationSummary  
You’ve now seen several ways that Silverlight helps you flag invalid data. First, as you learned in the 
previous chapter, most input controls change their appearance when something is amiss—for example, 
changing their border to a red outline. Second, these input controls also show a pop-up error message 
when the control has focus. Third, if you’re using the Label control, it turns its caption text red. And 
fourth, if you’re using the DescriptionViewer control, you can replace the default control template with 
one that reacts to invalid data (much as you can change the way a label and input controls display their 
error notifications by giving them custom control templates). 
All these techniques are designed to give in-situ error notifications—messages that appear next to or 
near the offending input. But in long forms, it’s often useful to show an error list that summarizes the 
problems in a group of controls. You can implement a list like this by reacting to the 
BindingValidationError described in the previous chapter. But Silverlight has an even easier option that 
does the job with no need for code: the ValidationSummary control. 
The ValidationSummary monitors a container for error events. For example, if you have Grid with 
input controls, you can point the ValidationSummary to that Grid using the Target property. It will then 
detect the errors that occur in any of the contained input controls. (Technically, you could point the 
ValidationSummary at a single input control, but that wouldn’t have much point.) Most of the time, you 
don’t need to set the Target property. If you don’t, the ValidationSummary retrieves a reference to its 
container and monitors all the controls inside. To create the summary shown in Figure 21-3, you need to 
add the ValidationSummary somewhere inside the Grid that holds the product text boxes: 
<dataInput:ValidationSummary Grid.Row="6" Grid.ColumnSpan="3" Margin="7" /> 
Figure 21-3. A validation summary with three errors 
www.it-ebooks.info
C# Word - Insert Image to Word Page in C#.NET
VB.NET How-to, VB.NET PDF, VB.NET Word, VB.NET Excel, VB.NET PowerPoint, VB.NET Tiff, VB.NET Imaging It's a demo code for adding image to word page using C#.
add page to pdf acrobat; adding a page to a pdf document
CHAPTER 21  DATA CONTROLS 
776 
 Note  Remember, to catch errors with the ValidationSummary, your bindings must have Mode set to TwoWay, 
and they must set ValidatesOnExceptions and NotifyOnValidationError to true. 
When no errors are present, the ValidationSummary is invisible and collapsed so that it takes no 
space. When there are one or more errors, you see the display shown in Figure 21-3. It consists of a 
header (which displays an error icon and the number of errors) and a list of errors that details the 
offending property and the exception message. If the user clicks one of the error message, the 
ValidationSummary fires the FocusingInvalidControl event and transfers focus to the input control with 
the data (unless you’ve explicitly set the FocusControlsOnClick property to false). 
If you want to prevent a control from adding its errors to the ValidationSummary, you can set the 
attached ShowErrorsInSummary property, as shown here: 
<TextBox Margin="5" x:Name="txtUnitCost" Width="100" HorizontalAlignment="Left" 
dataInput:ValidationSummary.ShowErrorsInSummary="False" 
Text="{Binding UnitCostMode=TwoWay, ValidatesOnExceptions=true, 
NotifyOnValidationError=true}"></TextBox
The ValidationSummary also provides several properties you can use to customize its appearance. 
Use HeaderTemplate to supply a data template that changes how the title is presented, use Header to 
supply your own custom header text, and use SummaryListBoxStyle to change how the error list is 
formatted. Programmatically, you may want to check the HasErrors property to determine whether the 
form is valid and the Errors collection to examine all the problems that were detected. 
THE DATAFIELD DATAFORM 
If you’re using the Silverlight Toolkit, you’ll find two tools that can help you build rich data forms. First up is 
the DataField control, an all-in-one package for editing a single bound property. The DataField control 
combines a Label control, a DescriptionViewer control, and an input control like the TextBox.  
Next is a more ambitious tool: the DataForm control. It’s a single container that creates all the bound 
controls needed to display and edit a data object. To use the DataForm to show a single data object, you 
set the CurrentItem property, like this: 
dataForm.CurrentItem = product; 
Or, if you have a collection of items, you can use the ItemsSource property instead: 
dataForm.ItemsSource = products; 
Either way, the data form creates the input controls you need for every property in your data object, 
complete with a label and DescriptionViewer for each one. If you use the ItemsSource property to bind 
multiple items, the DataForm even adds a bar with navigation controls to the top of the form. Using these 
controls, the user can step through the records, add new records, and delete existing ones. And it goes 
without saying that the DataForm includes numerous properties for tweaking its appearance and a 
www.it-ebooks.info
CHAPTER 21  DATA CONTROLS 
777 
customizable template that allows you to get more control over its layout. But for complete customizability, 
most developers will continue to create their data form markup by hand—at least until the DataForm 
becomes a bit more mature and is incorporated into the core Silverlight platform. 
Data Annotations 
Now that you’ve seen how to improve the error reporting in your forms, it’s worth considering a 
complementary feature that makes it easier to implement the validation rules that check your data. 
Currently, Silverlight validation responds to unhandled exceptions that occur when you attempt to set a 
property. If you want to implement custom validation, you’re forced to write code in the property setter 
that tests the new value and throws an exception when warranted. The validation code you need is 
repetitive to write and tedious to maintain. And if you need to check several different error conditions, 
your code can grow into a tangled mess that inadvertently lets certain errors slip past. 
Silverlight offers a solution with its new support for data annotations, which allow you to apply 
validation rules by attaching one or more attributes to the properties in your data class. Done right, data 
annotations let you move data validation out of your code and into the declarative metadata that 
decorates it, which improves the clarity of your code and the maintainability of your classes. 
 Notews 
the same model. Technically, you’ve already seen annotations at work, as the Display and Required attributes 
demonstrated in the previous section are both data annotations. 
Raising Annotation Errors 
Before you can use data annotations, you need to add a reference to the 
System.ComponentModel.DataAnnotations.dll assembly, which is the same assembly you used to 
access the Display and Required attributes in the previous section. You’ll find all the data-annotation 
classes in the matching namespace, System.ComponentModel.DataAnnotations. 
Data annotations work through a small set of attributes that you apply to the property definitions in 
your data class. Here’s an example that uses the StringLength attribute to cap the maximum length of 
the ModelName field at 25 characters: 
[StringLength(25)] 
[Display(Name = "Model Name", Description = "This is the retail product name.")] public string 
ModelName 
get return modelName; } 
set 
modelName = value
OnPropertyChanged(new PropertyChangedEventArgs("ModelName")); 
www.it-ebooks.info
CHAPTER 21  DATA CONTROLS 
778 
This setup looks perfect: the validation rule is clearly visible, easy to isolate, and completely separate 
from the property setting code. However, it’s not enough for Silverlight’s data-binding system. Even with 
data annotations, all of Silverlight’s standard controls require an exception before they recognize the 
presence of invalid data. 
Fortunately, there’s an easy way to throw the exception you need, when you need it. The trick is the 
Validator class, which provides several static helper methods that can test your data annotations and 
check your properties for bad data. The ValidateProperty() method throws an exception if a specific 
value is invalid for a specific property. The ValidateObject() method examines an entire object for 
problems and throws an exception if any property is out of whack. The TryValidateProperty() and 
TryValidateObject() methods perform much the same tasks, but they provide a ValidationResult object 
that explains potential problems rather than throwing a ValidationException. 
The following example shows the three lines of code you use to check a property value with the 
ValidateProperty() method. When called, this code examines all the validation attributes attached to the 
property and throws a ValidationException as soon as it finds one that’s been violated: 
[StringLength(25)] 
[Display(Name = "Model Name", Description = "This is the retail product name.")] 
public string ModelName 
get return modelName; } 
set 
// Explicitly raise an exception if a data annotation attribute 
// fails validation. 
ValidationContext context = new ValidationContext(thisnullnull);                 
context.MemberName = "ModelName"
Validator.ValidateProperty(value, context); 
modelName = value
OnPropertyChanged(new PropertyChangedEventArgs("ModelName")); 
By adding code like this to all your property setters, you can enjoy the best of the data-annotation 
system—straightforward attributes that encode your validation logic—and still plug your validation into 
the Silverlight data-binding system. 
 Note  Data annotations are powerful, but they aren’t perfect for every scenario. In particular, they still force your 
data class to throw exceptions to indicate error conditions. This design pattern isn’t always appropriate (for 
example, it runs into problems if you need an object that’s temporarily in an invalid state or you want to impose 
restrictions only for user edits, not programmatic changes). It’s also a bit dangerous, because making the wrong 
change to a data object in your code has the potential to throw an unexpected exception and derail your 
application. (To get around this, you can create an AllowInvalid property in your data classes that, when true, tells 
them to bypass the validation-checking code. But it’s still awkward at best.) For this reason, many developers 
prefer to use the IDataError or INotifyDataError interface with their data objects, as described in Chapter 20. 
www.it-ebooks.info
CHAPTER 21  DATA CONTROLS 
779 
The Annotation Attributes 
To use validation with data annotations, you need to add the right attributes to your data classes. The 
following sections list the attributes you can use, all of which derive from the base ValidationAttribute 
class and are found in the System.ComponentModel.DataAnnotations namespace. All of these attributes 
inherit the ValidationAttribute.ErrorMessage property, which you can set to add custom error message 
text. This text is featured in the pop-up error balloon and shown in the ValidationSummary control (if 
you’re using it). 
 Tip  You can add multiple restrictions to a property by stacking several different data annotation attributes. 
Required 
This attribute specifies that the field must be present—if it’s left blank, the user receives an error. This 
works for zero-length strings, but it’s relatively useless for numeric values, which start out as perfectly 
acceptable 0 values: 
[Required()] 
public string ModelNumber 
{ ... } 
Here’s an example that adds an error message: 
[Required(ErrorMessage="You must valid ACME Industries ModelNumber.")] 
public string ModelNumber 
{ ... } 
StringLength 
This attribute sets the maximum length of a string. You can also (optionally) set a minimum length by 
setting the MinimumLength property, as shown here: 
[StringLength(25, MinimumLength=5)] 
public string ModelName 
{ ... } 
When you’re using an attribute that has important parameters, like StringLength, you can add these 
details to your error message using numbered placeholders, where {0} is the name of the field that’s 
being edited, {1} is the constructor argument, {2} is the first attribute property, {3} is the second, and so 
on. Here’s an example: 
[StringLength(25, MinimumLength=5, ErrorMessage= 
"Model names must have between {2} and {1} characters.")] 
public string ModelName 
{ ... } 
When the StringLength causes a validation failure, it sets the error message to this text: “Model 
names must have between 5 and 25 characters.” 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested