c# : winform : pdf viewer : Add page numbers to pdf files Library software class asp.net winforms wpf ajax Pro_Silverlight_5_in_CSharp_4th_edition71-part139

CHAPTER 19  ASP.NET WEB SERVICES 
708 
Duplex services work best with small-scale use. If your application has a small, well-defined 
audience, duplex services offer an interesting technique for dealing with periodic updates or time-
consuming operations. In the following sections, you’ll see how to build a simple duplex service that 
handles a batch job. The client submits a job request, and the server completes the work asynchronously 
and then delivers the finished product back to the client. 
Configuring the Service 
To create a duplex service, you begin with the same steps you follow for an ordinary web service: you 
add a Silverlight-enabled WCF service to your project with the right name. In this example, the service is 
named AsyncTask.svc. 
When you add a new web service, Visual Studio adds three familiar ingredients: 
• The .svc file: This is the endpoint to your service. The client directs all its messages 
to this URL. In this example, the .svc file is named AsyncTask.svc, and you don’t 
need to make any modifications to it. 
• The web service code: This code isn’t much help for a duplex service. In the 
following sections, you’ll this service code with a more suitable version. 
• The web.config settings: These are partially correct, but they need some tweaking 
to support duplex communication. This is the task you’ll take on first. 
The following are the changes you need to make to the automatically generated settings in the 
web.config file to transform an ordinary web service into a duplex service. You can see the full 
web.config file with the sample code for this chapter. 
Before going any further, you need to add an assembly reference to the 
System.ServiceModel.PollingDuplex.dll assembly that has the duplexing support you need. You can find 
it in a folder like c:\Program Files (x86)\Microsoft SDKs\Silverlight\v5.0\Libraries\Server. 
Once you’ve taken care of that, you’re ready to make the first modification to the web.config file. 
Find the <system.serviceModel> element, and add this inside it: 
<extensions> 
<bindingExtensions> 
<add name="pollingDuplexHttpBinding" type= 
System.ServiceModel.PollingDuplex, Version=5.0.0.0, Culture=neutral, 
PublicKeyToken=31bf3856ad364e35"/> 
</bindingExtensions>       
</extensions> 
This pulls the class you need out of the System.ServiceModel.PollingDuplex.dll assembly and uses it 
to set up a binding extension. 
The next step is to find the <bindings> section. Remove the <customBinding> element that’s already 
there and add this one instead, which uses the binding extension you just configured: 
<pollingDuplexHttpBinding /> 
Finally, find the <services> section, which defines a single <service>. Remove the first <endpoint> 
element inside, and add this instead: 
<endpoint address="" binding="pollingDuplexHttpBinding" 
contract="IAsyncTaskService"/> 
www.it-ebooks.info
Add page numbers to pdf files - 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 to pdf documents; adding a page to a pdf file
Add page numbers to pdf files - 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; add page number to pdf
CHAPTER 19  ASP.NET WEB SERVICES 
709 
For this to work, you must create the IAsyncTaskService interface, which is the task outlined in the 
next section. If you give your service interface a different name, you’ll need to modify this configuration 
information to match. 
This configures your service to use the duplex binding. Now you’re ready to carry on and add the 
web service code. 
The Interfaces 
For a client application to have a two-way conversation with a web service, the client needs to know 
something about the web service, and the web service needs to know something about the client. Before 
you begin building any of the actual code, you need to formalize this arrangement by creating the 
interfaces that allow this interaction to happen. When calling the service, the client uses the service 
interface (which, in this example, is named IAsyncTaskService). When calling the client, the service uses 
the client interface (which is named IAsyncTaskClient). 
In this example, the server interface consists of single method named SubmitTask(). The client calls 
this method to pass the task request to the server. 
[ServiceContract(CallbackContract = typeof(IAsyncTaskClient))] 
public interface IAsyncTaskService 
[OperationContract(IsOneWay = true)] 
void SubmitTask(TaskDescription task); 
There are two important details to note here. First, the OperationContract that decorates the 
SubmitTask() method sets the IsOneWay property to true. This makes it a one-way method. When 
calling a one-way method, the client will disconnect after the request message is sent, without waiting 
for a response. This also makes the server-side programming model easier. Rather than starting a new 
thread or running a timer, the SubmitTask() can carry out its time-consuming work from start to finish, 
safe in the knowledge that the client isn’t waiting. 
The second important detail is found in the ServiceContract attribute that decorates the interface 
declaration. It sets the CallbackContract property to indicate the interface that the client will use. The 
client interface also consists of a single one-way method. This method is named ReturnResult(), and the 
server calls it to pass back the result to the client when the operation is complete. 
[ServiceContract
public interface IAsyncTaskClient 
[OperationContract(IsOneWay = true)] 
void ReturnResult(TaskResult result); 
These interfaces require two data classes. The TaskDescription class encapsulates the information 
in the task request that the client sends to the server. The TaskResult class encapsulates the final, 
processed data that the server returns to the client. 
[DataContract()] 
public class TaskDescription 
[DataMember()] 
public string DataToProcess{ getset; } 
www.it-ebooks.info
C# Create PDF Library SDK to convert PDF from other file formats
them the ability to count the page numbers of generated metadata adding control, you can add some additional Create PDF Document from Existing Files Using C#.
add a page to a pdf online; add contents page to pdf
C# Word - Word Create or Build in C#.NET
also offer them the ability to count the page numbers of generated using this Word document adding control, you can add some additional Create Word From PDF.
add page pdf reader; add page numbers to pdf document
CHAPTER 19  ASP.NET WEB SERVICES 
710 
[DataContract()] 
public class TaskResult 
[DataMember()] 
public string ProcessedData { getset; } 
In this example, both classes wrap a single string, and the “processing” consists of reversing the 
characters in that string. A more sophisticated example might generate a made-to-order bitmap, look up 
an archived document, or perform a statistical analysis of a set of numbers. 
The Service 
The service implements the IAsyncTaskService and provides the code for the SubmitTask() method. It 
isn’t decorated with the ServiceContract attribute (unlike the previous service examples), because that 
attribute is already present on the interface. 
The actual code in the SubmitTask() method is refreshing simple. As in any other web service 
method, it carries out the operation and prepares the return value. The difference is that the return value 
is passed by explicitly calling the IAsyncTaskClient.ReturnResult() method. 
[AspNetCompatibilityRequirements(RequirementsMode 
AspNetCompatibilityRequirementsMode.Allowed)] 
public class AsyncTask IAsyncTaskService  
public void SubmitTask(TaskDescription taskDescription) 
{  
// Simulate some work with a delay. 
Thread.Sleep(TimeSpan.FromSeconds(15)); 
// Reverse the letters in string. 
char[] data = taskDescription.DataToProcess.ToCharArray(); 
Array.Reverse(data); 
// Prepare the response. 
TaskResult result = new TaskResult(); 
result.ProcessedData = new string(data); 
// Send the response to the client. 
try 
IAsyncTaskClient client =  
OperationContext.Current.GetCallbackChannel<IAsyncTaskClient>(); 
client.ReturnResult(result); 
catch 
// The client could not be contacted. 
// Clean up any resources here before the thread ends. 
www.it-ebooks.info
C# PowerPoint - PowerPoint Creating in C#.NET
New PowerPoint File and Load PowerPoint from Other Files. them the ability to count the page numbers of generated creating toolkit, if you need to add some text
add pdf pages to word; add and delete pages from pdf
C# Word - Word Creating in C#.NET
to Create New Word File and Load Word from Other Files. them the ability to count the page numbers of generated creating toolkit, if you need to add some text
add page to existing pdf file; adding page numbers to pdf in preview
CHAPTER 19  ASP.NET WEB SERVICES 
711 
Incidentally, a web service method can call the client.ReturnResult() method multiple times to 
return different pieces of data at different times. The connection to the client remains available until the 
reference is released (when the method ends and the variable goes out of scope). 
The Client 
The client code is the easiest piece of the puzzle. First, you need a reference to the 
System.ServiceModel.PollingDuplex.dll assembly. However, you can’t use the server-side version. 
Instead, you can find the Silverlight version in the folder c:\Program Files (x86)\Microsoft 
SDKs\Silverlight\v5.0\Libraries\Client
Now, when creating the proxy object, you need to explicitly create the duplex binding, as shown in 
the code here: 
private AsyncTaskServiceClient client; 
public MainPage() 
InitializeComponent(); 
EndpointAddress address = new EndpointAddress("http://localhost:" + 
HtmlPage.Document.DocumentUri.Port + "/DuplexService.Web/AsyncTask.svc"); 
PollingDuplexHttpBinding binding = new PollingDuplexHttpBinding(); 
client = new AsyncTaskServiceClient(binding, address); 
... 
When consuming an ordinary web service, you attach an event handler to the completed event. 
(You get one completed event for each web service method.) Using a duplex service is similar, but you 
get one event for each method in the client interface, and the word Received is added to the end instead 
of Completed. In the current example, the IAsyncTaskClient interface defines a single method named 
ReturnResult(), and so the proxy class includes an event named ReturnResultReceived(). 
... 
client.ReturnResultReceived += client_ReturnResultReceived; 
Figure 19-7 shows a simple client that allows the user to enter a string of text. When the user clicks 
the button, this text is send to the web service, which then processes it asynchronously. When the server 
calls the client back, the new information is displayed in a TextBlock underneath. 
www.it-ebooks.info
C# Excel - Excel Creating in C#.NET
to Create New Excel File and Load Excel from Other Files. them the ability to count the page numbers of generated creating toolkit, if you need to add some text
add page number to pdf reader; add page number to pdf hyperlink
VB.NET TIFF: VB.NET Sample Codes to Sort TIFF File with .NET
to sort a multi-page TIFF file with page numbers using VB define the orders for the TIFF file page sorting by pageCount - 1 To 0 Step -1 newOrders.Add(i) Next
adding a page to a pdf; add page number to pdf file
CHAPTER 19  ASP.NET WEB SERVICES 
712 
Figure 19-7. Processing text with a duplex service 
Here’s the code that makes it all happen: 
private void cmdSubmit_Click(object sender, RoutedEventArgs e) 
{    
TaskDescription taskDescription = new TaskDescription(); 
taskDescription.DataToProcess = txtTextToProcess.Text; 
client.SubmitTaskAsync(taskDescription); 
lblStatus.Text = "Asynchronous request sent to server."
private void client_ReturnResultReceived(object sender, 
ReturnResultReceivedEventArgs e) 
try 
lblStatus.Text = "Response received: " + e.result.ProcessedData; 
catch 
lblStatus.Text = "Job processing failed."
From the client’s point of view, the programming model seems quite similar. However, there are 
numerous differences: 
• The client doesn’t wait for the server’s response but polls for it periodically. 
www.it-ebooks.info
C#: Use XImage.OCR to Recognize MICR E-13B, OCR-A, OCR-B Fonts
may need to scan and get check characters like numbers and codes. page.RecSettings. LanguagesEnabled.Add(Language.Other); page.RecSettings.OtherLanguage
add page numbers pdf files; adding page numbers to pdf
VB.NET Excel: VB Methods to Set and Customize Excel Rendering
treat every single Excel spreadsheet as a page in our An image consists of large numbers of dots, and the Our Excel converting add-on for VB.NET still supports
add page number to pdf preview; adding page numbers in pdf file
CHAPTER 19  ASP.NET WEB SERVICES 
713 
• The server can hold onto the client reference for long periods of time and call the 
client multiple times before the method ends. The server could even keep the 
connection semipermanently or wire up a timer and send intermittent data 
refreshes to the client. 
• The server can call different client methods from the same web service method. In 
fact, the service can call any method that’s defined in the client interface. 
 Note  Duplex services are not designed for huge numbers of users. By default, duplex services cap themselves 
at ten simultaneous connections, but you can override this by using the code shown at 
http://tinyurl.com/m9bdn4
simultaneously connected clients—think dozens, not hundreds. 
The Last Word 
In this chapter, you explored the interaction between ASP.NET web services and Silverlight. You saw 
how to build a basic and more advanced web service, how to monitor the network connection of the 
local computer, and how to support two-way web service communication. You’ll build on these 
fundamentals in Chapter 20 and Chapter 21, as you explore how you can use a web service to provide 
your Silverlight application with information extracted from a server-side database. 
www.it-ebooks.info
C# Excel: Create and Draw Linear and 2D Barcodes on Excel Page
barcode image to the first page page.AddImage(barcodeImage C#.NET Excel Barcode Creating Add-on imaging controls, PDF document, image to pdf files and components
add pages to an existing pdf; adding page numbers in pdf
VB.NET Image: Guide to Convert Images to Stream with DocImage SDK
Follow this guiding page to learn how to easily convert a single image or numbers of it an image processing component which can enable developers to add a wide
adding a page to a pdf in reader; add page numbers pdf
C H A P T E R  20 
715 
Data Binding 
Data binding is the time-honored tradition of pulling information out of an object and displaying it in 
your application’s user interface, without writing the tedious code that does all the work. Often, rich 
clients use two-way data binding, which adds the ability to push information from the user interface 
back into some object—again, with little or no code. 
In Chapter 2, you learned how to use Silverlight data binding to link together two elements so that 
changing one affects the other. In this chapter, you’ll learn how to use binding to pull data values out of 
an object, display them, format them, and let users edit them. You’ll see how to get information from a 
server-side using a web service, how to format it with value converters, and how to shape it with data 
templates. You’ll even take a look at validation techniques and the INotifyDataErrorInfo interface. 
 What’s New  Silverlight 5 introduces several refinements to the data-binding system. First, it adds the 
straightforward DataContextChanged event to all elements, so you can tell when a new data object is set. Second, 
it adds support for relative source binding, which means you can create a data template that binds to a property in 
its parent control. More glamorously, Silverlight 5 gives Visual Studio the ability to debug data binding expressions, 
which is a great help for tracking down binding errors (see “Debugging a Data Binding Expression”); and it adds 
implicit data templates, which lets your data controls pick the right data template based on the type of object 
you’re binding (see “Implicit Data Templates”). 
Binding to Data Objects 
At its simplest, data binding is a process that tells Silverlight to extract a property value from a source 
object and use it to set a property in a target object. The source object can be just about anything, from 
an ordinary Silverlight element (as you saw in Chapter 2) to a custom data object (as you’ll see in the 
examples in this chapter). The target object must be an instance of a class that derives from 
DependencyObject, and the target property must be a dependency property. 
Usually, the target of a data binding is an element. This makes sense—after all, the ultimate goal of 
most Silverlight data binding is to display some information in your user interface. However, you can 
also use data binding to extract information from a source object and insert it in a brush, transform, 
bitmap effect, timeline, animation key frame, text element (in a RichTextBox), and more. For a complete 
www.it-ebooks.info
CHAPTER 20  DATA BINDING 
716 
list of classes that derive from DependencyObject (and are thus valid data binding targets), see the 
documentation at http://tinyurl.com/35gu6ph. 
Building a Data Object 
The best way to try Silverlight’s data-binding features is to create a simple data object. Then, you can use 
data-binding expressions to display the data from your data object without writing tedious data-display 
code. 
data object is a package of related information. Any class will work as a data object, provided it 
consists of public properties. (A data object can also have fields and private properties, but you can’t 
extract the information these members contain through data-binding expressions.) Furthermore, if you 
want the user to be able to modify a data object through data binding, its properties can’t be read-only. 
Here’s a simple data object that encapsulates the information for a single product in a product 
catalog: 
public class Product 
private string modelNumber; 
public string ModelNumber 
get { return modelNumber; } 
set { modelNumber = value; } 
private string modelName; 
public string ModelName 
get { return modelName; } 
set { modelName = value; } 
private double unitCost; 
public double UnitCost 
get { return unitCost; } 
set { unitCost = value; } 
private string description; 
public string Description 
get { return description; } 
set { description = value; } 
public Product(string modelNumber, string modelName, 
double unitCost, string description) 
ModelNumber = modelNumber; 
ModelName = modelName; 
UnitCost = unitCost; 
Description = description; 
www.it-ebooks.info
CHAPTER 20  DATA BINDING 
717 
This class uses explicit properties, rather than shorter and slightly more convenient automatic 
properties. This design allows you to edit the property procedures later so that you can add support for 
change notification and validation. 
Displaying a Data Object with DataContext 
Consider the simple page shown in Figure 20-1. It shows the information for a single product using 
several text boxes in a Grid. 
Figure 20-1. Displaying data from a Product object 
To build this example, you need some code that creates the Product object you want to display. In 
this example, you’ll use code to create a Product object using hard-coded details. Of course, in real life 
it’s much more likely that you’ll extract the data from another resource, such as a web service, an XML 
document, a file that’s been downloaded from the Web (see Chapter 23), and so on. You’ll explore a 
more realistic example that uses a full-fledged web service throughout this chapter, as you dig into data 
binding in more detail. 
To display the information from a Product object, you can obviously resort to tedious data-copying 
code like this: 
txtModelNumber = product.ModelNumber; 
www.it-ebooks.info
CHAPTER 20  DATA BINDING 
718 
This code is lengthy, error-prone, and brittle (for example, you’ll probably need to rewrite it if you 
choose to use different display controls). Data binding allows you to move the responsibility for 
transferring the data from your C# code to your XAML markup. 
To use data binding, you must set the target property using a binding expression. A binding 
expression is a markup extension (somewhat like the StaticResource extension you used in Chapter 2). 
It’s delineated by curly braces and always starts with the word Binding. The simplest binding expression 
that you can create requires one more detail: the name of the property in the source object that has the 
data you want to extract. 
For example, to access the Product.ModelNumber property, you use a binding expression like this: 
{Binding ModelNumber} 
And here’s how you use it to set the Text property in a text box: 
<TextBox Text="{Binding ModelNumber}"></TextBox> 
Using this straightforward technique, it’s easy to build the page shown in Figure 20-1, with its four 
binding expressions: 
<Grid Name="gridProductDetails"> 
<Grid.ColumnDefinitions> 
<ColumnDefinition Width="Auto"></ColumnDefinition> 
<ColumnDefinition></ColumnDefinition> 
</Grid.ColumnDefinitions> 
<Grid.RowDefinitions> 
<RowDefinition Height="Auto"></RowDefinition> 
<RowDefinition Height="Auto"></RowDefinition> 
<RowDefinition Height="Auto"></RowDefinition> 
<RowDefinition Height="Auto"></RowDefinition> 
<RowDefinition Height="*"></RowDefinition> 
</Grid.RowDefinitions> 
<TextBlock Margin="7">Model Number:</TextBlock> 
<TextBox Margin="5" Grid.Column="1" 
Text="{Binding ModelNumber}"></TextBox> 
<TextBlock Margin="7" Grid.Row="1">Model Name:</TextBlock> 
<TextBox Margin="5" Grid.Row="1" Grid.Column="1" 
Text="{Binding ModelName}"></TextBox> 
<TextBlock Margin="7" Grid.Row="2">Unit Cost:</TextBlock> 
<TextBox Margin="5" Grid.Row="2" Grid.Column="1" 
Text="{Binding UnitCost}"></TextBox> 
<TextBlock Margin="7,7,7,0" Grid.Row="3">Description:</TextBlock> 
<TextBox Margin="7" Grid.Row="4" Grid.Column="0" Grid.ColumnSpan="2" 
TextWrapping="Wrap" Text="{Binding Description}"></TextBox> 
</Grid> 
The binding expressions specify the name of the source property, but they don’t indicate the source 
object. You can set the source object in one of two ways: by setting the DataContext property of an 
element or by setting the Source property of a binding. 
In most situations, the most practical approach is to set the DataContext property, which every 
element includes. In the previous example, you could set the DataContext property of all four text boxes. 
However, there’s an easier approach. If an element uses a binding expression and its DataContext 
property is null (which is the default), the element continues its search up the element tree. This search 
continues until the element finds a data object or reaches the top-level container, which is the user 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested