c# : winform : pdf viewer : Add page to existing pdf file Library control class asp.net web page winforms ajax Pro_Silverlight_5_in_CSharp_4th_edition74-part142

CHAPTER 20  DATA BINDING 
739 
 Noteclass from the one in which it’s 
used. Technically
shown here won’t work if you haven’t imported the System.Linq namespace. 
The ToList() method causes the LINQ expression to be evaluated immediately. The end result is an 
ordinary List collection, which you can deal with in all the usual ways. If you want to make the collection 
editable so that changes show up in bound controls immediately, you’ll need to copy the contents of the 
List to a new ObservableCollection. 
Master-Details Display 
As you’ve seen, you can bind other elements to the SelectedItem property of your list to show more 
details about the currently selected item. Interestingly, you can use a similar technique to build a 
master-details display of your data. For example, you can create a page that shows a list of categories 
and a list of products. When the user chooses a category in the first list, you can show just the products 
that belong to that category in the second list. Figure 20-8 shows this example. 
Figure 20-8. A master-details list 
www.it-ebooks.info
Add page to existing pdf file - 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 number to pdf; add page numbers pdf file
Add page to existing pdf file - 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 pages to pdf preview; adding page numbers to pdf in
CHAPTER 20  DATA BINDING 
740 
To pull this off, you need a parent data object that provides a collection of related child data objects 
through a property. For example, you can build a Category class that provides a property named 
Category.Products with the products that belong to that category. Like the Product class, the Category 
class can implement the INotifyPropertyChanged to provide change notifications. Here’s the complete 
code: 
public class Category INotifyPropertyChanged 
private string categoryName; 
public string CategoryName 
get return categoryName; } 
set { categoryName = value
OnPropertyChanged(new PropertyChangedEventArgs("CategoryName")); 
private List<Product> products; 
public List<Product> Products 
get return products; } 
set { products = value
OnPropertyChanged(new PropertyChangedEventArgs("Products")); 
public event PropertyChangedEventHandler PropertyChanged; 
public void OnPropertyChanged(PropertyChangedEventArgs e) 
if (PropertyChanged != null
PropertyChanged(this, e); 
public Category(string categoryName, List<Product> products) 
CategoryName = categoryName; 
Products = products; 
public Category(){} 
To use the Category class, you also need to modify the data-access code that you saw earlier. Now, 
you query the information about products and categories from the database. The example in Figure 20-8 
uses a web service method named GetCategoriesWithProducts(), which returns a collection of Category 
objects, each of which has a nested collection of Product objects: 
[OperationContract()] 
public List<Category> GetCategoriesWithProducts() 
// Perform the query for products using the GetProducts stored procedure. 
SqlConnection con = new SqlConnection(connectionString); 
SqlCommand cmd = new SqlCommand("GetProducts", con); 
www.it-ebooks.info
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Thumbnails. Page: Insert PDF Pages. Page: Delete Existing PDF Pages. Copy, Paste, Cut Image in Page. Link: Edit Redact Pages. Annotation & Drawing. Add Sticky Note
add and delete pages in pdf online; add page numbers to a pdf in preview
C# PDF File Compress Library: Compress reduce PDF size in C#.net
this PDF document compressing control is designed to offer C# developers to compress existing PDF documents in Embedded page thumbnails. Add necessary references
add or remove pages from pdf; add a page to a pdf online
CHAPTER 20  DATA BINDING 
741 
cmd.CommandType = CommandType.StoredProcedure; 
// Store the results (temporarily) in a DataSet. 
SqlDataAdapter adapter = new SqlDataAdapter(cmd); 
DataSet ds = new DataSet(); 
adapter.Fill(ds, "Products"); 
cmd.CommandText = "GetCategories"
adapter.Fill(ds, "Categories"); 
// Set up a relation between these tables. 
// This makes it easier to discover the products in each category. 
DataRelation relCategoryProduct = new DataRelation("CategoryProduct"
ds.Tables["Categories"].Columns["CategoryID"], 
ds.Tables["Products"].Columns["CategoryID"]); 
ds.Relations.Add(relCategoryProduct); 
// Build the collection of Category objects. 
List<Category> categories = new List<Category>(); 
foreach (DataRow categoryRow in ds.Tables["Categories"].Rows) 
List<Product> products = new List<Product>(); 
foreach (DataRow productRow in categoryRow.GetChildRows(relCategoryProduct)) 
products.Add(new Product(productRow["ModelNumber"].ToString(), 
productRow["ModelName"].ToString(), 
Convert.ToDouble(productRow["UnitCost"]), 
productRow["Description"].ToString())); 
categories.Add(new Category(categoryRow["CategoryName"].ToString(), 
products)); 
return categories; 
To display this data, you need the two lists shown here: 
<ListBox x:Name="lstCategories" DisplayMemberPath="CategoryName" 
SelectionChanged="lstCategories_SelectionChanged"></ListBox> 
<ListBox x:Name="lstProducts" Grid.Row="1" DisplayMemberPath="ModelName"> 
</ListBox> 
After you receive the collection from the GetCategoriesWithProducts() method, you can set the 
ItemsSource of the topmost list to show the categories: 
lstCategories.ItemsSource = e.Result; 
To show the related products, you must react when an item is clicked in the first list and then set the 
ItemsSource property of the second list to the Category.Products property of the selected Category 
object: 
lstProducts.ItemsSource = ((Category)lstCategories.SelectedItem).Products; 
www.it-ebooks.info
C# PDF insert image Library: insert images into PDF in C#.net, ASP
Add multiple images to multipage PDF document in .NET WinForms. Ability to put image into specified PDF page position and save existing PDF file or output a
add remove pages from pdf; add page number to pdf online
VB.NET PDF insert image library: insert images into PDF in vb.net
Add images to any selected PDF page in VB.NET. Ability to put image into defined location on PDF page. Save changes to existing PDF file or output a new PDF file
add pages to pdf document; add page to a pdf
CHAPTER 20  DATA BINDING 
742 
Alternatively, you can perform this step using another binding expression in XAML, rather than 
code. The trick is to use the SelectedValuePath property, which is provided by the ListBox and 
ComboBox. 
Essentially, the SelectedValuePath tells the list control to expose a specific property of the bound 
object through the SelectedValue property of the list. If you’ve bound a collection of Category objects, 
you can tell the ListBox to provide the Category.Products collection through the ListBox.SelectedValue 
property like this: 
<ListBox x:Name="lstCategories" DisplayMemberPath="CategoryName" 
SelectedValuePath="Products"></ListBox
Then you can use the SelectedValuePath to write a binding expression for the second list box: 
<ListBox x:Name="lstProducts" Grid.Row="1" DisplayMemberPath="ModelName" 
ItemsSource="{Binding ElementName=lstCategories, Path=SelectedValue}"> 
</ListBox> 
Now, selected a category in the first list box causes the list of products to appear in the second list 
box, with no code required. 
 Note  In this example, the full category and product information is downloaded from the web service at once. 
But if your application uses a much larger product catalog and most users need to view only one or two 
categories, you might be better off downloading just the subset of products you want to view. In this case, you 
would react to the SelectionChanged event of the category list box and retrieve the CategoryID of the currently 
selected category (using the SelectedItem or SelectedValue property). Then, you would perform a new web service 
call to get the products in that c
needs to perform and slow down your application. You’ll need to weight the trade-offs carefully and (at the very 
least) consider caching product information in the client after it’s downloaded for the first time. 
Validation 
When the Silverlight data-binding system encounters invalid data, it usually ignores it. For example, 
consider the following list, which details the three types of errors that can occur when you’re editing a 
two-way field: 
• Incorrect data type: For example, a numeric property like UnitCost can’t 
accommodate letters or special characters. Similarly, it can’t hold extremely large 
numbers (numbers larger than 1.79769313486231570E+308). 
• Property setter exception: For example, a property like UnitCost may use a range 
check and throw an exception if you attempt to set a negative number. 
• Read-only property: This can’t be set at all. 
If you run into these errors, you’re likely to miss them, because the Silverlight data-binding system 
doesn’t give you any visual feedback. The incorrect value remains in the bound control, but it’s never 
applied to the bound object. 
www.it-ebooks.info
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
applications to delete any unnecessary page from target existing PDF document file. C#.NET Project DLLs for Deleting PDF Document Page. Add necessary references
add pages to pdf; add page numbers to a pdf file
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
Existing PDF Pages. |. Home ›› XDoc.PDF ›› VB.NET PDF: Delete PDF Page. DLLs for Deleting Page from PDF Document in VB.NET Class. Add necessary references:
add a page to a pdf in reader; adding pages to a pdf
CHAPTER 20  DATA BINDING 
743 
To avoid confusion, it’s a good idea to alert users to their mistakes as soon as possible. In the 
following sections, you’ll learn how to respond to these issues and design data objects that have built-in 
validation. 
Error Notifications 
The first step to implementing error notifications is to set the ValidatesOnExceptions property of the 
binding to true. This tells the data-binding system to pay attention to all errors, whether they occur in 
the type converter or the property setter. But when ValidatesOnException is set to false (the default), the 
data-binding system fails silently when it hits these conditions. The data object isn’t updated, but the 
offending value remains in the bound control. 
Here’s an example that applies this property to the binding for UnitCost: 
<TextBox Margin="5" Grid.Row="2" Grid.Column="1" x:Name="txtUnitCost" 
Text="{Binding UnitCostMode=TwoWay, ValidatesOnExceptions=True}"></TextBox> 
This simple change gives your application the ability to catch and display errors, provided you’re 
using two-way data binding with a control that supports the ValidationState group of control states. 
These are some of the controls that support this feature (with no extra work required): 
• TextBox 
• PasswordBox 
• CheckBox 
• RadioButton 
• ListBox 
• ComboBox 
In Chapter 14, you learned that control states are animations that change the way a control looks at 
certain times. In the case of validation, a control must support three states: Valid, InvalidUnfocused, and 
InvalidFocused. Together, these states make up the ValidationState group, and they allow a control to 
vary its appearance when it contains invalid data. 
To understand how this works, it helps to consider the simple example of a text box with invalid 
data. First, consider a version of the Product class that uses this code to catch negative prices and raise 
an exception: 
private double unitCost; 
public double UnitCost 
get { return unitCost; } 
set 
if (value < 0) throw new ArgumentException("Can't be less than 0."); 
unitCost = value
Now, consider what happens if the user enters a negative number. In this case, the property setter 
will throw an ArgumentException. BecauseValidatesOnException is set to true, this exception is caught 
www.it-ebooks.info
VB.NET PDF Password Library: add, remove, edit PDF file password
On this page, we will illustrate how to protect PDF document via Add necessary references Visual Basic coding example will help you open an encrypted PDF file.
add page numbers to pdf document in preview; add page numbers to pdf in reader
C# PDF Password Library: add, remove, edit PDF file password in C#
your PDF document in C# project, XDoc.PDF provides some PDF security settings. On this page, we will talk about how to achieve this via Add necessary references
add pdf pages to word; add page numbers to pdf document
CHAPTER 20  DATA BINDING 
744 
by the data-binding system, which then switches the ValidationState of the text box from Valid to 
InvalidFocused (if the text box currently has focus) or InvalidUnfocused (if the text box doesn’t). 
 Tip  If you have Visual Studio set to break an all exceptions, Visual Studio will notify you when the 
ArgumentException is thrown and switch into break mode. To carry on and see what happens when the exception 
reaches the data-binding system, choose Debug 
Continue or just press the shortcut key F5. 
In the unfocused state, the text box gets a dark red border with an error-notification icon (a tiny red 
triangle) in the upper-right corner. In its focused state, or when the user moves the mouse over the error 
icon, the exception message text appears in a pop-up red alert balloon. Figure 20-9 shows both states. 
Figure 20-9. The InvalidUnfocused state (left) and InvalidFocused state (right) of a text box 
 Note  For the red pop-up balloon to appear properly, sufficient space must be available between the text box 
and the edges of the browser window. If there is space on the right side of the text box, the balloon appears there. 
If not, it appears on the left. The balloon appears on top of any other elements that are in the same place, such as 
buttons or labels. However, it can’t stretch out of the browser window. In the example shown in Figure 20-9, the 
width of the UnitPrice text box is limited to make sure there is room on the right side. Finally, if the message is too 
long to fit in the available space, part of it is chopped off. 
www.it-ebooks.info
CHAPTER 20  DATA BINDING 
745 
At first glance, the error pop-ups seem easy and incredibly useful. Because the control takes care of 
the visual details, you simply need to worry about reporting helpful error messages. But there is a 
disadvantage to wiring the validation display into the control template: if you want to change the way a 
control displays error messages (or disable error display altogether), you need to replace the entire 
control template, making sure to include all the other unrelated states and markup details. And as you 
already know, the average control template is quite lengthy, so this process is tedious and potentially 
limiting. (For example, it may prevent you from using someone else’s customized template to get more 
attractive visuals if you’re already relying on your own custom template to tweak the error-display 
behavior.) 
 Note  In Chapter 21, you’ll learn about another way to display error information, with the ValidationSummary 
control. It collects the error messages from a collection of child elements and lists it in a single place of your 
choosing. 
The BindingValidationFailed Event 
Error notifications are a great way to inform the user about potential problems. But there are a whole 
host of situations in which you’ll want more control over what happens next. In these cases, you need to 
intercept the BindingValidationFailed event and use custom code. 
To enable the BindingValidationFailed event, you must set ValidatesOnExceptions to true (to detect 
errors) and NotifyOnValidationError to true (to fire the validation events). Here’s an example:  
<TextBox Margin="5" Grid.Row="2" Grid.Column="1" x:Name="txtUnitCost" 
Text="{Binding UnitCostMode=TwoWay, ValidatesOnExceptions=True, 
NotifyOnValidationError=True}"></TextBox> 
BindingValidationError is a bubbling event, which means you can handle it where it occurs (in the 
text box) or at a higher level (such as the containing Grid). Handling errors where they occur gives you 
the opportunity to write targeted error-handling logic that deals separately with errors in different fields. 
Handling them at a higher level (as shown here) allows you to reuse the same logic for many different 
types of errors: 
<Grid Name="gridProductDetails" 
BindingValidationError="Grid_BindingValidationError"> 
The final step is to do something when the problem occurs. You may choose to display a message or 
change the appearance of some part of your application, but the real power of the 
BindingValidationError event is that it lets you perform other actions, such as changing focus, resetting 
the incorrect value, trying to correct it, or offering more detailed, targeted help based on the specific 
mistake that was made. 
The following example displays an error message and indicates the current value (see Figure 20-10). 
It also transfers focus back to the offending text box, which is a heavy-handed (but occasionally useful) 
technique. It has the side effect of making sure the control remains in the InvalidFocused state rather 
than the InvalidUnfocused state, so the pop-up error message also remains visible: 
private void Grid_BindingValidationError(object sender, ValidationErrorEventArgs e) 
// Display the error. 
www.it-ebooks.info
CHAPTER 20  DATA BINDING 
746 
lblInfo.Text = e.Error.Exception.Message; 
lblInfo.Text += "\nThe stored value is still: " + 
((Product)gridProductDetails.DataContext).UnitCost.ToString(); 
// Suggest the user try again. 
txtUnitCost.Focus(); 
Figure 20-10. Pointing out a validation error 
The BindingValidationError event happens only when the value is changed and the edit is 
committed. In the case of the text box, this doesn’t happen until the text box loses focus. If you want 
errors to be caught more quickly, you can use the BindingExpression.UpdateSource() method to force 
immediate updates as the user types, as described in the previous section. 
 Tip  If you don’t reset the value in the text box, the incorrect value remains on display, even though it isn’t 
stored in the bound data object. You might choose to allow this behavior so that users have another chance to edit 
invalid values. 
www.it-ebooks.info
CHAPTER 20  DATA BINDING 
747 
Whatever steps you take in this event handler happen in addition to the control state change. 
Unfortunately, you can’t selectively disable control error reporting and choose to receive the 
BindingValidationError event. 
The Validation Class 
You don’t need to wait for the BindingValidationError event to detect invalid data. You can check a 
bound control at any time using the static methods of the Validation class. Validation.GetHasErrors() 
returns true if the control has failed validation, and Validation.GetErrors() returns the appropriate 
collection of one of more exception objects. 
These methods give you added flexibility. For example, you can check HasErrors() and refuse to let 
the user continue to a new step or perform a specific function if invalid data exists. Similarly, you can use 
GetErrors() to round up a series of mistakes at the end of a data-entry process, so you can provide an 
itemized list of problems in one place. 
Creating Data Objects with Built-in Validation 
Earlier, you saw the simplest way to build validation logic into a data object—by throwing exceptions for 
bad data (such as negative numbers in the UnitCost property). However, raising exceptions is a slightly 
dangerous and often reckless way to implement validation. One problem is that the exception-raising 
code can inadvertently rule out perfectly reasonable uses of the data object. For example, it might not 
make sense for the UnitsInStock property to hold a value of –10, but if the underlying database stores 
this value, you might still want to create the corresponding Product object so you can manipulate it in 
your application. 
Most purists prefer not to raise exceptions to indicate user input errors. There are several reasons 
that underlie this design choice—for example, a user input error isn’t an exceptional condition, error 
conditions may depend on the interaction between multiple property values, and it’s sometimes 
worthwhile to hold on to incorrect values for further processing rather than reject them outright. 
Instead, cautious developers rely on other techniques to flag invalid data. 
In Silverlight, your data objects can provide built-in validation by implement the IDataErrorInfo or 
INotifyDataErrorInfo interface. Both of these interfaces have the same goal—they replace aggressive 
unhandled exceptions with a politer system of error notification. The IDataErrorInfo interface is the 
original error-tracking interface, which dates back to the first version of .NET. Silverlight includes it for 
backward compatibility. The INotifyDataErrorInfo interface is a similar but richer interface that was 
introduced with Silverlight 4. It has support for additional features, such as multiple errors per property 
and rich error objects. 
No matter which interface you use, there are three basic steps to follow: 
• Implement the IDataErrorInfo or INotifyDataErrorInfo interface in your data 
object. 
• Tell the data binding infrastructure to check the data object for errors and show 
error notifications. If you’re using the IDataErrorInfo interface, you set 
ValidatesOnDataErrors to true. If you’re using the INotifyDataErrorInfo interface, 
you set ValidatesOnNotifyDataErrors to true. 
• Optionally, set NotifyOnValidationError to true if you want to receive the 
BindingValidationFailed event. 
• Optionally, set the ValidatesOnExceptions property to true if you want to catch 
other types of errors, such as data conversion problems. 
www.it-ebooks.info
CHAPTER 20  DATA BINDING 
748 
 Note  If you’re using a web service, remember that Visual Studio can’t transfer the code from a server-defined 
data object to the automatically generated client-side copy. This isn’t a problem for basic data objects, but it is a 
serious obstacle if you want to create a rich data object that implements features such as validation. In this 
situation, you need to use the type sharing feature described in Chapter 19, which lets you manually add a 
synchronized copy of the data class to both projects. 
The following example shows how to use the INotifyDataErrorInfo interface to detect problems with 
the Product object. The first step is to implement the interface: 
public class Product INotifyPropertyChangedINotifyDataErrorInfo 
{ ... } 
The INotifyDataErrorInfo interface requires just three members. The ErrorsChanged event fires 
when an error is added or removed. The HasErrors property returns true or false to indicate whether the 
data object has errors. Finally, the GetErrors() method provides the full error information. 
Before you can implement these methods, you need a way to track the errors in your code. The best 
bet is a private collection, like this: 
private Dictionary<stringList<string>> errors =  
new Dictionary<stringList<string>>(); 
At first glance, this collection looks a little odd. To understand why, you need to know to facts. First, 
the INotifyPropertyChanged interface expects you to link your errors to a specific property. Second, each 
property can have one or more errors. The easiest way to track this error information is with a 
Dictionary<T, K> collection that’s indexed by property name: 
private Dictionary<stringList<string>> errors =  
new Dictionary<stringList<string>>(); 
Each entry in the dictionary is itself a collection of errors. This example uses a simple List<Of T> 
List<T> of strings: 
private Dictionary<stringList<string>> errors =  
new Dictionary<stringList<string>>(); 
However, you could use a full-fledged error object to bundle together multiple pieces of information 
about the error, including details such as a text message, error code, severity level, and so on. 
Once you have this collection in place, you simply need to add to it when an error occurs (and 
remove the error information if the error is corrected). The make this process easier, the Product class in 
this example adds a pair of private methods named SetErrors() and ClearErrors(): 
public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged; 
private void SetErrors(string propertyName, List<string> propertyErrors) 
// Clear any errors that already exist for this property. 
errors.Remove(propertyName); 
// Add the list collection for the specified property. 
errors.Add(propertyName, propertyErrors); 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested