Note  This two-part communication process means that it takes a bit more work to handle a web service call 
than to interact with an ordinary local object. However, it also ensures that developers create responsive Silverlight 
applications. After all, making an HTTP call to a web service can take as long as one minute (using the default 
timeout setting), so it’s not safe to make the user wait. (And yes, Microsoft imposes this limitation to ensure that 
your code can’t give its platform a bad name.) 
Here’s how to call the TestService.GetServerTime() method shown earlier: 
// Create the proxy class. 
TestServiceClient proxy = new TestServiceClient(); 
// Attach an event handler to the completed event. 
proxy.GetServerTimeCompleted += new 
// Start the web service call. 
To get the results, you need to handle the completed event and examine the corresponding 
EventArgs object. When generating the proxy class, Visual Studio also creates a different EventArgs class 
for each method. The only difference is the Result property, which is typed to match the return value of 
the method. For example, the GetServerTime() method works in conjunction with a 
GetServerTimeCompletedEventArgs class that provides a DateTime object through its Result property. 
When accessing the Result property for the first time, you need to use exception-handling code. 
That’s because this is the point where an exception will be thrown if the web service call failed—for 
example, the server couldn’t be found, the web service method returned an error, or the connection 
timed out. (As an alternative, you could check the Error property of the custom EventArgs object. For 
example, if GetServerTimeCompletedEventArgs.Error is null, no error occurred while processing the 
request, and it’s safe to get the data from the Result property.) 
Here’s an event handler that reads the result (the current date and time on the server) and displays 
it in a TextBlock: 
private void GetServerTimeCompleted(object sender, 
GetServerTimeCompletedEventArgs e) 
lblTime.Text = e.Result.ToLongTimeString(); 
catch (Exception err) 
lblTime.Text = "Error contacting web service"
Add a page to a pdf document - insert pages into PDF file in, 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 pdf in reader; add page number to pdf hyperlink
Add a page to a pdf document - VB.NET PDF Page Insert Library: insert pages into PDF file in, ASP.NET, MVC, Ajax, WinForms, WPF
Easy to Use VB.NET APIs to Add a New Blank Page to PDF Document
adding page numbers to pdf document; add page number to pdf reader
 Tip  Even though web service calls are performed on a background thread, there’s no need to worry about 
thread marshaling when the completed event fires. The proxy class ensures that the completed event fires on the 
main user-interface thread, allowing you to access the controls in your page without any problem. 
By default, the proxy class waits for one minute before giving up if it doesn’t receive a response. You 
can configure the timeout length by using code like this before you make the web service call: 
proxy.InnerChannel.OperationTimeout = TimeSpan.FromSeconds(30); 
You might think that when a web service method throws an exception, you can catch it in your Silverlight 
code. But life isn’t that simple. 
Although this chapter focuses on using web services for a single purpose—communicating between 
Silverlight and ASP.NET—thee standards that underpin web services are far broader and more general. 
They’re designed to allow interaction between applications running on any web-enabled platform, and as 
such they don’t incorporate any concepts that would tie them to a single, specific technology (like .NET 
exception classes). 
There’s another consideration: security. Web services can be consumed by any web-enabled application, 
and there’s no way for your web service code to verify that it’s your Silverlight application making the call. 
If web service methods returned specific, detailed exceptions, they would reveal far too much about their 
internal workings to potential attackers. 
So, what happens when you call a web service method that goes wrong? First, the web server returns a 
generic fault message is returned to the client application. This message uses the HTTP status code 500, 
which signifies an internal error. Because of security restrictions in the browser, even if there were more 
information in the fault message, your Silverlight application wouldn’t be allowed to access it because of 
the status code. Instead, Silverlight detects the fault message and immediately throws a 
CommunicationException with no useful information. 
There is a way to work around this behavior and return more detailed exception information from the 
server, but because of the security concerns already mentioned, this feature is best for debugging. To get 
this error information, you need to take two somewhat tedious steps. First, you need to use a specialized 
WCF behavior that changes the HTTP status code of server-side fault messages from 500 to 200 before 
they’re sent to the client. (The browser places no restriction on reading information from a response when 
the HTTP status code is 200.) Second, you need a mechanism to return the exception information. 
Silverlight includes a web service configuration option that, if enabled, inserts exception into the fault 
message. With these two details in place, you’re ready to receive error information.
VB.NET PDF insert image library: insert images into PDF in
VB.NET PDF - Add Image to PDF Page in VB.NET. Guide VB.NET Programmers How to Add Images in PDF Document Using XDoc.PDF SDK for VB.NET.
add page number to pdf; add page to pdf reader
C# PDF insert image Library: insert images into PDF in, ASP
How to insert and add image, picture, digital photo, scanned signature or logo into PDF document page in C#.NET class application?
add pages to pdf acrobat; adding page numbers in pdf
For more information, refer to
, which shows the 
WCF behavior that changes the status code, the configuration setting that inserts exception details into 
fault messages, and the client-side code that digs out the error information. 
Configuring the Web Service URL 
When you add a service reference, the automatically generated code includes the web service URL. As a 
result, you don’t need to specify the URL when you create an instance of the proxy class. 
But this raises a potential problem. All web service URLs are fully qualified—relative paths aren’t 
allowed. If you’re using the test web server in Visual Studio, that means you’ll run into trouble if you try 
to run your application at a later point, when the test web server has chosen a different port number. 
Similarly, you’ll need to update the URL when you deploy your final application to a production web 
You can solve this problem by updating the service reference (and thereby regenerating all the proxy 
code), but there are two easier options. 
Your first option is to configure Visual Studio to always use a specific port when running its test web 
server with your web application. This works only if you’ve created your web application as a web 
project (not a projectless website). In this case, you can configure the test web server for your project by 
double-clicking the Properties item in the Solution Explorer. Choose the Web tab. Then, in the Servers 
section, select “Specific port” and enter the port number you’d like to use. (You may as well choose the 
port number that the test server is already using for this session.) In the settings shown in Figure 19-3, 
that port number is 54752.
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 page numbers to pdf using preview; adding page to pdf
VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.
This .NET PDF Document Add-On integrates mature PDF document page processing functions, including extracting one or more page(s) from PDF document.
add pages to pdf without acrobat; add page to pdf acrobat
Figure 19-3. Setting the port for the test web server 
Now you can modify the code that creates your proxy class. Instead of simply using this, which 
assumes the service is at the same port that it occupied when you added the reference: 
TestServiceClient proxy = new TestServiceClient(); 
You can explicitly set the port with the EndpointAddress class: 
// Create the proxy class. 
TestServiceClient proxy = new TestServiceClient(); 
// Use the port that's hard-coded in the project properties. 
EndpointAddress address = new EndpointAddress
// Apply the new URI. 
proxy.Endpoint.Address = address; 
Your second option is to change the address dynamically in your code so that it’s synchronized with 
the port number that the test web server is currently using. To do so, you simply need to grab the URL of
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.
adding page numbers to pdf in preview; add a page to pdf file
C# PDF File & Page Process Library SDK for, ASP.NET, MVC
Insert Image to PDF. Image: Remove Image from PDF Page. Image: Copy, Paste, Cut Image in Page. Link: Edit Images. Redact Pages. Annotation & Drawing. Add Sticky
adding page numbers pdf file; add contents page to pdf
the Silverlight page and find its port number (because the Silverlight page is hosted on the same web 
server as the web service). Here’s the code that does the trick: 
EndpointAddress address = new EndpointAddress("http://localhost:" + 
HtmlPage.Document.DocumentUri.Port + "/ASPWebSite/TestService.svc"); 
// Use the new address with the proxy object. 
TestServiceClient proxy = new TestServiceClient(); 
proxy.Endpoint.Address = address; 
You can use similar code to create a URL based on the current Silverlight page so that the web 
service continues to work no matter where you deploy it, as long as you keep the web service and 
Silverlight application together in the same web folder. 
Using a Busy Indicator 
Depending on exactly what your web method does, it may take a noticeable amount of time. If this delay 
isn’t handled carefully, it can frustrate or confuse the user. For example, the user might assume there’s a 
problem with the application, attempt to repeat the same action, or even restart the application. 
One way to deal with slow services is to add some sort of indicator that informs the user that a web 
service call is underway. Although you can use any Silverlight element as an indicator (and even use the 
animation techniques you picked up in Chapter 10 and Chapter 11), the easiest solution is a dedicated 
control called the BusyIndicator, which is included in the Silverlight Toolkit 
The BusyIndicator has two display states: its ordinary state and its busy state. In its ordinary state, 
the BusyIndicator shows the content (if any) that’s set in the Content property. In its busy state, the 
BusyIndicator fuses together an endlessly pulsating progress bar with whatever content you supply in 
the BusyContent property. Here’s an example: 
<toolkit:BusyIndicator x:Name="busy" BusyContent="Contacting Service..." /> 
To put the BusyIndicator into its busy state, simply set the IsBusy property. Here’s the updated web 
service code: 
private void cmdCallSlowService_Click(object sender, RoutedEventArgs e) 
TestServiceClient proxy = new TestServiceClient(); 
cmdCallSlowService.IsEnabled = false
lblTime.Text = ""
busy.IsBusy = true
proxy.GetServerTimeCompleted += new 
private void GetServerTimeCompleted(object sender, 
GetServerTimeCompletedEventArgs e) 
VB.NET PDF Page Delete Library: remove PDF pages in, 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:
adding pages to a pdf document in preview; add a page to a pdf document
C# PDF Page Extract Library: copy, paste, cut PDF pages in
pageIndexes.Add(3); // The 4th page. String outputFilePath = Program.RootPath + "\\" Output.pdf"; newDoc.Save(outputFilePath);
add or remove pages from pdf; adding a page to a pdf file
lblTime.Text = e.Result.ToLongTimeString(); 
catch (Exception err) 
lblTime.Text = "Error contacting service."
busy.IsBusy = false
cmdCallSlowService.IsEnabled = true
And Figure 19-4 shows the result, while the web service call is underway. 
Figure 19-4. Showing the status of an in-progress call 
Web Service Data Types 
When you create a web service for use with Silverlight, you’re limited to the core set of .NET data types. 
This includes strings, Boolean values, bytes, numeric data types, enumeration values, and DateTime 
objects. You can also use arrays, collections of any supported type, and—more interestingly—custom 
classes that are build with these same data types.
Custom Data Classes 
To build a custom class that works with a web service, you need to meet a few basic requirements: 
• Your class declaration must be decorated with the DataContract attribute. 
• Your class must consist of public, writeable properties. Each property must use 
one of the previously discussed serializable data types, or another custom class. 
• Each property must be decorated with the DataMember attribute to indicate that 
it should be serialized. 
• Your class must include a zero-argument default constructor. 
• Your class can include code, but it won’t be accessible on the client. Instead, the 
client will get a stripped-down version of the class with no code. 
Here’s an example of a custom class that satisfies all these conditions: 
public class Customer 
private string firstName; 
private string lastName; 
public string FirstName 
get { return firstName; } 
set { firstName = value; } 
public string LastName 
get { return lastName; } 
set { lastName = value; } 
Now you can create a web service method that uses this class. 
[AspNetCompatibilityRequirements(RequirementsMode = 
public class TestService 
public Customer GetCustomer(int customerID) 
Customer newCustomer = new Customer(); 
// (Look up and configure the Customer object here.) 
return newCustomer;
The web method can use this class for a parameter or a return value (as in this example). Either way, 
when you add the service reference in your Silverlight project, Visual Studio generates a similar 
Customer class definition in your Silverlight application, alongside the proxy class. You can then interact 
with the Customer objects that the server sends back, or you can create Customer objects in the client 
and send them to the server. 
private void GetCustomerCompleted(object sender, 
GetCustomerCompletedEventArgs e) 
Customer newCustomer = e.Result; 
catch (Exception err) 
lblTime.Text = "Error contacting web service"
You’ll see a much more in-depth example of a web service that uses custom classes later in this 
book. In Chapter 20, you’ll build a web service that uses custom classes and collections to return data 
from a database. 
Web Service Type Sharing 
As you’ve seen so far, a layer of cross-platform standards separates your Silverlight client from the 
ASP.NET web services it uses. One consequence of this separation is that web services and clients can’t 
share code. If a web service returns a data object like an instance of the Customer class shown in the 
previous section, the client gets a stripped-down version of that class with all the public data (as 
properties) and none of the code. 
Usually, this design isn’t a problem. As long as Visual Studio follows a few simple rules—for 
example, using property procedures instead of public fields and using ObservableCollection for any sort 
of collection of objects—the code-free data classes it generates will work fine with Silverlight data 
binding. However, there are some situations when you might want to work around this limitation, create 
a data class that includes code, and use that code on both the server and client sides of your solution. For 
example, you could use this technique to create a code-enriched version of the Customer class shown in 
the previous section and make that code accessible to both the web service and the Silverlight client. 
To share a data class, you need to take two steps: 
Share the code: You need to give a copy of the data class to both the web service 
and the Silverlight client. This is tricky, because the web service targets the full 
.NET Framework, whereas the client targets the scaled-down Silverlight 
libraries. Thus, even though they both can use the same data class code, they 
can’t share a single data class assembly, because that assembly must be 
compiled for one platform or the other. The best solution is to create two class 
library assemblies—one for ASP.NET and one for Silverlight—and use Visual 
Studio linking to avoid duplicating your source files. 
Identify the code: Once both projects have the data class, you still need a way to 
tell Visual Studio that they are one and the same. Otherwise, Visual Studio will 
still attempt to create a stripped-down client-side copy when you add the web
reference. To identify your data class, you simply need to give it a unique XML 
In the following sections, you’ll tackle both of these steps, but in the reverse order. 
 Note  Think carefully before you use web service type sharing. In most cases, it’s best to avoid type sharing, 
because type sharing creates a tight dependency between your server-side code and your Silverlight client, which 
can complicate versioning, updating, and deployment. However, type sharing sometimes make sense when you’re 
building smart data objects that have embedded details such as descriptive text and validation rules. In many 
cases, you aren’t actually sharing code but the attributes that decorate it. You’ll see an example that uses type 
sharing for this purpose in Chapter 21. 
Identifying Your Data Classes 
As you already know, the data classes you use in a WCF web service need to have the DataContract 
attribute. But the DataContract attribute doesn’t just make your class usable in a web service. It also 
gives you the ability to uniquely identify your class by mapping it to an XML namespace of your choice. 
So far, the examples you’ve seen haven’t used this ability, because it isn’t required. But if you’re 
deploying data-class code to the client, it’s essential. That’s because you must give the same XML 
namespace to both the Silverlight version and the ASP.NET version of each data class. Only then will 
Visual Studio understand that it represents the same entity. 
Here’s an example that maps the Customer class to the XML namespace 
[DataContract(Name = "Customer", 
Namespace = "")] 
public class Customer 
private string firstName; 
private string lastName; 
public string FirstName 
get { return firstName; } 
set { firstName = value; } 
public string LastName 
get { return lastName; } 
set { lastName = value; } 
// Ordinarily, this method would not be available on the client.
public string GetFullName() 
 return firstName + " " + lastName; 
Remember, XML namespaces don’t need to point to web locations (even though they commonly 
use URIs). Instead, you can use a domain you control in your XML namespace to ensure that it’s not 
inadvertently duplicated by another developer. 
Sharing the Code 
You may assume that after you’ve set up the DataContract attribute, you can copy the data-class code to 
your web service and Silverlight project. Unfortunately, life isn’t this simple. Even though the 
DataContract attribute uniquely identifies the Customer class, Visual Studio still attempts to create new 
data classes when you create a reference to your web service (and it tries to regenerate them every time 
you refresh that reference). As it currently stands, that means your web service client code ends up using 
a stripped-down duplicate copy of the Customer class. 
To fix this problem and get Visual Studio to use the same data classes in both projects, you need to 
create the correct project structure. At a bare minimum, you must place the client-side versions of the 
data classes in a separate assembly. 
Here’s the sequence of steps to follow: 
1. Begin with a solution that includes your Silverlight project and the ASP.NET 
website with the data web service. (In the downloadable example for this 
chapter, that’s a Silverlight application named TypeSharingClient and an 
ASP.NET website named TypeSharing.Web.) 
 Note  This approach works e
in Visual Studio. 
2. Add a new Silverlight class library application for the data classes. (In the 
downloadable example, it’s called DataClasses.) This project needs to have a 
reference to the System.Runtime.Serialization.dll assembly in order to use the 
DataContract attribute. 
3. Add a reference in your Silverlight project that points to the data-class project 
so the data classes are available in your application. 
4. Add a new .NET class library for the server-side implementation of the data 
classes (for example, DataClasses.ServerSide). It will also need a reference to 
the System.Runtime.Serialization.dll assembly, only now you’re using the full 
.NET version of that assembly. Figure 19-5 shows all the projects in the 
Documents you may be interested
Documents you may be interested