c# : winform : pdf viewer : Add page pdf reader software SDK dll windows wpf .net web forms Pro_Silverlight_5_in_CSharp_4th_edition72-part140

CHAPTER 20  DATA BINDING 
719 
control that represents the page. In the preceding example, that means you can save considerable effort 
by setting the Grid.DataContext property. All the text boxes then use the same data object. 
Here’s the code that creates the Product object and sets the Grid.DataContext property when the 
page first loads: 
private void Page_Loaded(object sender, RoutedEventArgs e) 
Product product = new Product("AEFS100""Portable Defibrillator", 77, 
"Analyzes the electrical activity of a person's heart and applies " + 
"an electric shock if necessary."); 
gridProductDetails.DataContext = product; 
If you don’t run this code, no information will appear. Even though you’ve defined your bindings, 
no source object is available, so the elements in your page will remain blank. 
 Tip  Usually, you’ll place all your bound controls in the same container, and you’ll be able to set the DataContext 
once on the container rather than for each bound element. 
Storing a Data Object as a Resource 
You have one other option for specifying a data object. You can define it as a resource in your XAML 
markup and then alter each binding expression by adding the Source property. 
For example, you can create the Product object as a resource using markup like this: 
<UserControl.Resources> 
<local:Product x:Key="resourceProduct" 
ModelNumber="AEFS100" 
ModelName="Portable Defibrillator" UnitCost="77" 
Description="Analyzes the electrical activity of a person's heart and applies 
an electric shock if necessary."> 
</local:Product> 
</UserControl.Resources> 
This markup assumes you’ve mapped the project namespace to the XML namespace prefix local. 
For example, if the project is named DataBinding, you need to add this attribute to the UserControl start 
tag: 
xmlns:local="clr-namespace:DataBinding" 
To use this object in a binding expression, you need to specify the Source property. To set the 
Source property, you use a StaticResource expression that uses the resource’s key name: 
<TextBox 
Text="{Binding ModelNumberSource={StaticResource resourceProduct} }"> 
</TextBox> 
Unfortunately, you must specify the Source property in each data-binding expression. If you need to 
bind a significant number of elements to the same data object, it’s easier to set the DataContext property 
www.it-ebooks.info
Add page pdf reader - 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
adding page numbers pdf file; add page to pdf preview
Add page pdf reader - 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 blank page to pdf preview; add pages to pdf without acrobat
CHAPTER 20  DATA BINDING 
720 
of a container. In this situation, you can still use the StaticResource to set the DataContext property, 
which allows you to bind a group of nested elements to a single data object that’s defined as a resource: 
<Grid Name="gridProductDetails" DataContext="{StaticResource resourceProduct}"> 
Either way, when you define a data object as a resource, you give up a fair bit of freedom. Although 
you can still alter that object, you can’t replace it. If you plan to retrieve the details for your data object 
from another source (such as a web service), it’s far more natural to create the data object in code. 
Incidentally, the Binding markup extension supports several other properties along with Source, 
including Mode (which lets you use two-way bindings to edit data objects) and Converter (which allows 
you to modify source values before they’re displayed). You’ll learn about Mode in the next section and 
Converter later in this chapter. 
Null Values and Failed Bindings 
Binding expressions also include two ways to fill in values when your binding doesn’t work exactly the 
way you want it to work. First, you can use the TargetNullValue property of the binding to set a default 
value that should apply when the bound data is a null reference. Here’s an example: 
<TextBox 
Text="{Binding ModelNameTargetNullValue='[No Model Name Set]' }"> 
</TextBox
Now, if the Product.ModelName property is a null reference, you’ll see the message “[No Model 
Name Set]” appear in the bound text box. Without the TargetNullValue setting, no text will appear. 
The second tool for dealing with binding problems is the FallbackValue property. This sets a value 
that appears when the binding fails to load any data. Here’s an example: 
<TextBox 
Text="{Binding ModelNameTargetNullValue='[No Model Name Set]', 
FallbackValue='N/A' }"> 
</TextBox
Now, the text “N/A” appears in the text box if the entire bound object is null or if it doesn’t contain a 
ModelName property. The “[No Model Name Set]” text appears if the object exists but the value of the 
ModelName property is  null. 
Editing with Two-Way Bindings 
At this point, you may wonder what happens if the user changes the bound values that appear in the text 
controls. For example, if the user types in a new description, is the in-memory Product object changed? 
To investigate what happens, you can use code like this that grabs the current Product object from 
the DataContext and displays its properties in a TextBlock: 
Product product = (Product)gridProductDetails.DataContext; 
lblCheck.Text = "Model Name: " + product.ModelName + "\nModel Number: " 
product.ModelNumber + "\nUnit Cost: " + product.UnitCost; 
If you run this code, you’ll discover that changing the displayed values has no effect. The Product 
object remains in its original form. 
www.it-ebooks.info
C# PDF insert image Library: insert images into PDF in C#.net, ASP
How to insert and add image, picture, digital photo, scanned signature or logo into PDF document page in C#.NET class application?
add page numbers to pdf in reader; add page to pdf acrobat
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
VB.NET Page: Insert PDF pages; VB.NET Page: Delete PDF Add Image to PDF; VB.NET Protect: Add Password to VB.NET Annotate: PDF Markup & Drawing. XDoc.Word for C#;
add page numbers to a pdf; add page numbers to a pdf document
CHAPTER 20  DATA BINDING 
721 
This behavior results because binding expressions use one-way binding by default. However, 
Silverlight actually allows you to use one of three values from the System.Windows.Data.BindingMode 
enumeration when setting the Binding.Mode property. Table 20-1 has the full list. 
Table 20-1. Values from the BindingMode Enumeration 
Name 
Description 
OneWay The target property is updated when the source property changes. 
TwoWay The target property is updated when the source property changes, and the source property 
is updated when the target property changes. 
OneTime The target property is set initially based on the source property value. However, changes are 
ignored from that point onward. Usually, you use this mode to reduce overhead if you know 
the source property won’t change. 
If you change one or more of your bindings to use two-way binding, the changes you make in the 
text box are committed to the in-memory object as soon as the focus leaves the text box (for example, as 
soon as you move to another control or click a button). 
<TextBox Text="{Binding UnitCost, Mode=TwoWay}"></TextBox> 
 Note  When you use two-way binding with a text box, the in-memory data object isn’t modified until the text box 
loses focus. However, other elemtion 
in a list box, move the thumb in a slider, or change the state of a check box, the source object is modified 
immediately. 
In some situations, you need to control exactly when the update is applied. For example, you may 
need to have a text box apply its changes as the user types, rather than wait for a focus change. In this 
situation, you need to do the job manually by calling the BindingExpression.UpdateSource() method in 
code. Here’s the code that forces the text box to update the source data object every time the user enters 
or edits the text: 
private void txtUnitCost_TextChanged(object sender, TextChangedEventArgs e) 
BindingExpression expression = 
txtUnitCost.GetBindingExpression(TextBox.TextProperty); 
expression.UpdateSource(); 
If you reach the point where all your updates are being made through code, you can disable 
Silverlight’s automatic updating system using the UpdateSourceTrigger property of the Binding object, 
as shown here: 
<TextBox Text= 
www.it-ebooks.info
VB.NET PDF insert image library: insert images into PDF in vb.net
VB.NET PDF - Add Image to PDF Page in VB.NET. Have a try with this sample VB.NET code to add an image to the first page of PDF file. ' Open a document.
add page to pdf; add pages to pdf document
VB.NET PDF Password Library: add, remove, edit PDF file password
On this page, we will illustrate how to protect PDF document via password by using simple VB.NET demo code. Open password protected PDF. Add password to PDF.
add page numbers pdf files; add a page to a pdf in reader
CHAPTER 20  DATA BINDING 
722 
"{Binding UnitCostMode=TwoWay, UpdateSourceTrigger=Explicit}"></TextBox> 
Silverlight supports only two values for UpdateSourceTrigger: Default and Explicit. It isn’t possible 
to choose PropertyChanged (as it is in WPF). But with a little code and the UpdateSource() method, you 
can ensure that updates occur whenever you need. 
 Note  Once you allow someonand 
deal with invalid data. Later in this chapter, in the “Validation” section, you’ll learn about the many options 
Silverlight provides for preventing problems with data entry. 
Change Notification 
In some cases, you may want to modify a data object after it’s been bound to one or more elements. For 
example, consider this code, which increases the current price by 10%: 
Product product = (Product)gridProductDetails.DataContext; 
product.UnitCost *= 1.1; 
 Note  If you plan to modify a bound object frequently, you don’t need to retrieve it from the DataContext 
property each time. A better approach is to store it using a field in your page, which simplifies your code and 
requires less type casting. 
This code won’t have the effect you want. Although the in-memory Product object is modified, the 
change doesn’t appear in the bound controls. That’s because a vital piece of infrastructure is missing—
quite simply, there’s no way for the Product object to notify the bound elements. 
To solve this problem, your data class needs to implement the 
System.ComponentModel.INotifyPropertyChanged interface. The INotifyPropertyChanged interface 
defines a single event, which is named PropertyChanged. When a property changes in your data object, 
you must raise the PropertyChanged event and supply the property name as a string. 
Here’s the definition for a revamped Product class that uses the INotifyPropertyChanged interface, 
with the code for the implementation of the PropertyChanged event: 
public class Product INotifyPropertyChanged 
public event PropertyChangedEventHandler PropertyChanged; 
public void OnPropertyChanged(PropertyChangedEventArgs e) 
if (PropertyChanged != null
PropertyChanged(this, e); 
... 
www.it-ebooks.info
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
adding pages to a pdf document; add and remove pages from pdf file online
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
DLLs for Deleting Page from PDF Document in VB.NET Class. In order to run the sample code, the following steps would be necessary. Add necessary references:
add pages to an existing pdf; adding page numbers to pdf document
CHAPTER 20  DATA BINDING 
723 
Now, you need to fire the PropertyChanged event in all your property setters: 
private double unitCost; 
public double UnitCost 
get { return unitCost; } 
set { 
unitCost = value
OnPropertyChanged(new PropertyChangedEventArgs("UnitCost")); 
If you use this version of the Product class in the previous example, you get the behavior you expect. 
When you change the current Product object, the new information appears in the bound text boxes 
immediately. 
 Tip  If several values have changed, you can call OnPropertyChanged() and pass in an empty string. This tells 
Silverlight to reevaluate the binding expressions that are bound to any property in your class. 
Debugging a Data Binding Expression 
Data binding mistakes are easy to make but more difficult to catch. For example, if you bind to a 
property that doesn’t exist, you won’t get a helpful compile-time error to point out your mistake. 
Instead, you’ll simply end up with a blank text box where you expect to see your data. The same is true if 
the property is private or if the property getter throws an exception. Similarly, edits fail if the property 
setter throws an exception or Silverlight fails to convert the edited value to the appropriate data type. 
If a data binding error is the result of a user’s edit, you may not be able to prevent the problem. 
Instead, you can use validation (discussed later in this chapter) to identify the error and notify the user. 
But if the problem is the result of a mistake in your code, it’s obviously up to you to hunt it down and fix 
it before your application goes any further. 
Fortunately, Silverlight has a handy debugging feature that lets you dissect data-binding problems. 
To use it, you start by setting a breakpoint on a troublemaking binding expression. To do that, you open 
your XAML file in Visual Studio and click the margin next to your binding expression, as shown in Figure 
20-2. 
www.it-ebooks.info
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
C#.NET Project DLLs for Deleting PDF Document Page. In order to run the sample code, the following steps would be necessary. Add necessary references:
add page break to pdf; adding a page to a pdf document
C# PDF Sticky Note Library: add, delete, update PDF note in C#.net
C#.NET Tutorial for How to Add a Sticky Note Annotation to PDF Page with Visual enable users to annotate PDF without adobe PDF reader control installed.
add pages to pdf acrobat; add page to pdf in preview
CHAPTER 20  DATA BINDING 
724 
Figure 20-2. Adding a data-binding breakpoint 
Now, Visual Studio will enter break mode immediately after it executes the binding expression but 
before it displays the results. At this point, you can investigate the binding information or press F5 to 
continue running your application. If you want to examine several binding expressions, you can set 
several breakpoints at the same time. 
The best tool for investigating your binding is the Locals window. When you hit a data-binding 
breakpoint, the Locals window shows the BindingState object. If you expand that object, you’ll see a 
number of useful properties (Figure 20-3). For example, the Action property tells you exactly why the 
binding expression is being called. If it’s set to UpdatingTarget, the binding expression is about to place 
a value in the bound control. If it’s set to UpdatingSource, the binding expression is about to apply a 
user-edited value to the data source. Similarly, you can examine the LastCompletedStage property to 
determine what happened before the breakpoint was triggered. For example, if the LastCompletedStage 
is set to TypeConversion and your binding expression is showing an error, it’s logical to assume that the 
data conversion was the problem. 
www.it-ebooks.info
CHAPTER 20  DATA BINDING 
725 
Figure 20-3. Investigating the BindingState 
The most useful BindingState property, by far, is the Error property. It provides an exception object 
that details the current problem, if there is one. Figure 20-3 shows what you’ll see if you create a binding 
to a property that doesn’t exist and set a breakpoint on it. The full error text is as follows: 
System.Windows.Data Error: BindingExpression path error: 
'DataBinding.Local.Product' (HashCode=49011679). 
BindingExpression: Path='Model_Number' 
DataItem='Portable Defibrillator (AEFS100)' (HashCode=49011679); 
target element is 'System.Windows.Controls.TextBox' (Name=''); 
target property is 'Text' (type 'System.String'). 
Here, the problem is that the real ModelNumber field doesn’t have an underscore. Clearly, getting 
this information is better than staring at a blank text box. 
 Note  Data-binding expressions are evaluated only if there’s an actual bound data object. If your data object is a 
null value, Silverlight won’t take any action, and your breakpoint won’t be triggered. However, you can use the 
FallbackValue property to substitute a different value, as described earlier. 
www.it-ebooks.info
CHAPTER 20  DATA BINDING 
726 
Building a Data Service 
Although the examples you’ve seen so far have walked you through the basic details of Silverlight data 
binding, they haven’t been entirely realistic. A more typical design is for your Silverlight application to 
retrieve the data objects it needs from an external source, such as a web service. In the examples you’ve 
seen so far, the difference is minimal. However, it’s worth stepping up to a more practical example 
before you begin binding to collections. After all, it makes more sense to get your data from a database 
than to construct dozens or hundreds of Product objects in code. 
In the examples in this chapter, you’ll rely on a straightforward data service that returns Product 
objects. You’ve already learned to create a WCF service (and consume it) in Chapter 19. Building a data 
service is essentially the same. 
The first step is to move the class definition for the data object to the ASP.NET website. (If you’re 
creating a projectless website, you must place the code file in the App_Code folder. If you’re creating a 
web project, you can place it anywhere.) The data object needs a few modifications: the addition of the 
DataContract and DataMember attributes to make it serializable and the addition of a public no-
argument constructor that allows it to be serialized. Here’s a partial listing of the code, which shows you 
the general outline you need: 
[DataContract()] 
public class Product INotifyPropertyChanged 
private string modelNumber; 
[DataMember()] 
public string ModelNumber 
get { return modelNumber; } 
set 
modelNumber = value
OnPropertyChanged(new PropertyChangedEventArgs("ModelNumber")); 
private string modelName; 
[DataMember()] 
public string ModelName 
get { return modelName; } 
set 
modelName = value
OnPropertyChanged(new PropertyChangedEventArgs("ModelName")); 
... 
public Product(){} 
www.it-ebooks.info
CHAPTER 20  DATA BINDING 
727 
WEB SERVICES AND INOTIFYPROPERTYCHANGED 
tification for free. That’s 
because when Visual Studio generates the client-side copy of a data class, it automatically implements the 
INotifyPropertyChanged interface, even if the server-side original doesn’t. 
For example, if you define a super-simple Product class like this: 
[DataContract()] 
public class Product INotifyPropertyChanged 
[DataMember()] 
public string ModelNumber { getset; } 
[DataMember()] 
public string ModelName { getset; } 
[DataMember()] 
public decimal UnitCost { getset; } 
[DataMember()] 
public string Description{ getset; } 
the client-side copy still implements INotifyPropertyChanged, has full property procedures, and calls 
OnPropertyChanged() when to raise a notification event when any property changes. 
You can inspect the client-side code for the data class by opening the Reference.cs file in your Silverlight 
project. (This file is hidden, so to see it, you need to first click the Show All Files button in the Solution 
Explorer. You’ll find it in the Solution Explorer if you drill down. For example, the Product class in the 
current example is in Solution Explorer 
Service References 
DataService 
Reference.svcmap 
Reference.cs.) 
This design raises a good question—namely, if INotifyPropertyChanged is implemented automatically in 
the client, should you even bother to implement it on the server? This decision is a matter of personal 
preference. Some developers feel that explicitly implementing the interface on the server side is clearer, 
while others don’t bother because change notification is a client-side feature that’s rarely used on the 
server. 
Finally, it’s worth noting that you can disable this feature and tell Visual Studio not to use 
INotifyPropertyChanged when it generates client-side data classes. To do so, you must edit the 
Reference.svcmap file in your Silverlight property. Just look for the <EnableDataBinding> element, and 
change its content from “true” to “false”. However, there’s really no good reason to take this step. 
With the data object in place, you need a web service method that uses it. The web service class is 
exceedingly simple—it provides just a single method that allows the caller to retrieve one product 
record. Here’s the basic outline: 
[ServiceContract(Namespace = "")] 
www.it-ebooks.info
CHAPTER 20  DATA BINDING 
728 
[AspNetCompatibilityRequirements(RequirementsMode = 
AspNetCompatibilityRequirementsMode.Allowed)] 
public class StoreDb 
private string connectionString = 
WebConfigurationManager.ConnectionStrings["StoreDb"].ConnectionString; 
[OperationContract()] 
public Product GetProduct(int ID) 
... 
The query is performed through a stored procedure in the database named GetProduct. The 
connection string isn’t hard-coded—instead, it’s retrieved through a setting in the web.config file, which 
makes it easy to modify this detail later. Here’s the section of the web.config file that defines the 
connection string: 
<configuration> 
... 
<connectionStrings> 
<add name="StoreDb" connectionString
/> 
</connectionStrings> 
... 
</configuration> 
The database component that’s shown in the following example retrieves a table of product 
information from the Store database, which is a sample database for the fictional IBuySpy store included 
with some Microsoft case studies. You can get a script to install this database with the downloadable 
samples for this chapter (or you can use an alternative version that grabs the same information from an 
XML file). 
In this book, we’re primarily interested in how data objects can be bound to Silverlight elements. 
The actual process that deals with creating and filling these data objects (as well as other 
implementation details, such as whether StoreDb caches the data over several method calls, whether it 
uses stored procedures instead of inline queries, and so on) isn’t our focus. However, just to get an 
understanding of what’s taking place, here’s the complete code for the data service: 
[ServiceContract(Namespace = "")] 
[AspNetCompatibilityRequirements(RequirementsMode = 
AspNetCompatibilityRequirementsMode.Allowed)] 
public class StoreDb 
private string connectionString = 
WebConfigurationManager.ConnectionStrings["StoreDb"].ConnectionString; 
[OperationContract()] 
public Product GetProduct(int ID) 
SqlConnection con = new SqlConnection(connectionString); 
SqlCommand cmd = new SqlCommand("GetProductByID", con); 
cmd.CommandType = CommandType.StoredProcedure; 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested