c# free pdf viewer component : Add a page to pdf file software application dll windows winforms asp.net web forms Pro_Silverlight_5_in_CSharp_4th_edition23-part86

Programmatically Retrieving a Resource 
Using resources is easy when you have an element that supports Silverlight’s URI standard, such as 
Image or MediaElement. However, in some situations, you need to manipulate your resource in code 
before handing it off to an element, or you may not want to use an element at all. For example, you may 
have some static data in a text or binary file that’s stored as a resource. In your code, you want to retrieve 
this file and process its data. 
To perform this task, you need the help of the Application.GetResourceStream() method. It allows 
you to retrieve the data for a specific resource, which you indicate by supplying the correct URI. The 
trick is that you need to use the following URI format: 
For example, if you have a resource named ProductList.bin in a project named 
SilverlightApplication1, you use this line of code: 
StreamResourceInfo sri = Application.GetResourceStream( 
new Uri("SilverlightApplication1;component/ProductList.bin"UriKind.Relative)); 
The GetResourceStream() method doesn’t retrieve a stream. Instead, it gets a 
System.Windows.Resources.StreamResourceInfo object, which wraps a Stream property (with the 
underlying stream) and a ContentType property (with the MIME type). Here’s the code that creates a 
BinaryReader object for the stream: 
BinaryReader reader = new BinaryReader(sri.Stream); 
You can now use the methods of the binary reader to pull each piece of data out of the file. The same 
approach works with StreamReader (for text-based data) and XmlReader (for XML data). But you have a 
slightly easier option when XML data is involved, because the XmlReader.Create() method accepts either 
a stream or a URI string that points to a resource. So, if you have a resource named ProductList.xml, this 
code works: 
StreamResourceInfo sri = Application.GetResourceStream( 
new Uri("SilverlightApplication1;component/ProductList.xml"UriKind.Relative)); 
XmlReader reader = XmlReader.Create(sri.Stream, new XmlReaderSettings()); 
So does this more streamlined approach: 
XmlReader reader = XmlReader.Create("ProductList.xml"
Placing Resources in the Application Package 
Your second option for resource storage is to place it in the XAP file where your application assembly is 
stored. To do this, you need to add the appropriate file to your project and change the build action to 
Content. Best of all, you can use almost the same URLs. Just precede them with a forward slash, as 
shown here: 
<Image Source="/grandpiano.jpg"></Image> 
Similarly, here’s a resource in a subfolder in the XAP: 
<Image Source="/Images/grandpiano.jpg"></Image> 
The leading slash represents the root of the XAP file. 
If you add the extension .zip to your XAP file, you can open it and verify that the resource file is 
stored inside, as shown in Figure 6-7. 
Add a page to 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 to pdf online
Add a page to 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 page numbers to pdf files; add page number to pdf print
Figure 6-7. A resource in a XAP file 
Placing resources in the XAP file gives you the same easy deployment as embedding them in the 
assembly. However, it adds a bit of flexibility. If you’re willing to do a little more work, you can 
manipulate the files in the XAP file (for example, updating a graphic) without recompiling the 
application. Furthermore, if you have several class library assemblies in the same XAP file, they can all 
use the same resource files in the XAP. (This is an unlikely arrangement but a possible one.) Overall, 
placing resources in the application package is a similar approach to embedding them in the assembly. 
Placing Resources on the Web 
Your third option is to remove resource files from your application but make them available on the Web. 
That way, your application can download them when needed. Thanks to Silverlight’s URI support, you 
can usually use this scenario without writing any extra code to deal with the download process. 
The simplest option when deploying resources on the Web is to place them in the same web 
location as your Silverlight assembly. If you’re using an ASP.NET test website, you can easily add a 
resource file to the test website—just place it in the ClientBin folder where the XAP file is located. If 
you’re using an HTML test page, the easiest option is to tell Visual Studio to copy your resource file to 
the build location. To do so, begin by adding the resource file to your Silverlight project. Then, select the 
resource file and choose None for the build action, so it won’t be compiled into the XAP. Finally, set the 
Copy to Output Directory setting to Copy Always. 
When using web resources, you use the same URIs as when placing resources in the application 
package. These are relative URIs prefaced with a forward slash. Here’s an example: 
<Image Source="/grandpiano.jpg"></Image
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
C# File: Split PDF; C# Page: Insert PDF pages; C# Page: Delete PDF pages; C# C# Read: PDF Image Extract; C# Write: Insert text into PDF; C# Write: Add Image to
add page numbers to pdf in preview; add page number to pdf in preview
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 and remove pages from pdf file online; add pdf pages to word document
Silverlight checks the XAP file first and then checks the folder where the XAP file is located. Thus, 
you can freely switch between the XAP file approach and the website approach after you’ve compiled an 
application—you just need to add or remove the resource files in the XAP file. 
Web-deployed resources don’t need to be located at the same site as your XAP file, although that’s 
the most common approach. If you use an absolute URL, you can show an image from any location: 
<Image Source="http://www.mysite.com/Images/grandpiano.jpg"></Image> 
 Note  When you’re testing an application that uses images with absolute URLs, a small glitch can creep in. The 
problem is that the Image element can’t perform cross-scheme access, which means that if you’re running 
Silverlight directly from your hard drive using a simple HTML test page, you can’t retrieve an image from the Web. 
To resolve this problem, add an ASP.NET test website to your project, as described in Chapter 1. 
Web-deployed resources are treated in a significantly different way in your application. Because 
they aren’t in the XAP file (either directly or indirectly, as part of the assembly), they aren’t compressed. 
If you have a large, easily compressed file (say, XML data), this means the web-deployed option results in 
longer download times, at least for some users. More significant is the fact the web-deployed resources 
are downloaded on demand, when they’re referenced in your application. Thus, if you have a significant 
number of large resources, web deployment is often much better—it trades a long delay on startup for 
many smaller delays when individual resources are accessed. 
 Note  The obvious disadvantage with all of these resource-storing approaches is that they require fixed, 
unchanging data. In other words, there’s no way for your application to modify the resource file and then save the 
modified version in the assembly, XAP file, or website. (In theory, the last option—website uploading—could be 
made possible, but it would create an obvious security hole.) The best solution when you need to change data is to 
use isolated storage (if storing the changed data locally is a good enough solution) or a web service (if you need a 
way to submit changes to the server). These approaches are discussed in Chapter 22 and Chapter 19, 
Failing to Download Resources 
When you use web-deployed resources, you introduce the possibility that your resources won’t be where 
you expect them to be and that you won’t be able to download them successfully. Elements that use the 
URI system often provide events to notify when a download can’t be completed, such as ImageFailed for 
the Image and MediaFailed for the MediaElement. 
Failing to download a resource isn’t considered a critical error. For example, if the Image element 
fails to find the right picture, it simply remains blank. But you can react to the corresponding failure 
event to update your user interface. 
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 or remove pages from pdf; add page to pdf reader
C# PDF insert image Library: insert images into PDF in C#.net, ASP
using RasterEdge.Imaging.Basic; using RasterEdge.XDoc.PDF; Have a try with this sample C#.NET code to add an image to the first page of PDF file.
adding page numbers to pdf document; add page to pdf
Downloading Resources with WebClient 
You can’t access web-deployed resources using the handy Application.GetResourceStream() method. As 
a result, if you want to use the data from a web-deployed resource and you don’t have an element that 
uses Silverlight URIs, you’ll need to do more work. 
In this situation, you need to use the System.Net.WebClient class to download the resource. The 
WebClient class provides three key methods. OpenReadAsync() is the most useful—it downloads a file as 
blob of binary data, which is then exposed as a stream. By comparison, DownloadStringAsync() 
downloads the contents into a single string. Finally, CancelAsync() halts any download that’s currently 
WebClient does its work asynchronously. You can respond to the DownloadProgressChanged event 
while the download is underway to find out how many bytes have been retrieved so far. When the 
download is complete, you can respond to the OpenReadCompleted or DownloadStringCompleted 
event, depending on which operation you’re using, and then retrieve your content. 
WebClient has the following important limitations: 
• It doesn’t support downloading from the file system: To use the WebClient class, 
you must be running your application through a web server. The easiest way to do 
this in Visual Studio is to let Visual Studio create an ASP.NET website, which is 
then hosted by the integrated web server (as described in Chapter 1). If you open 
your Silverlight page directly from the file system, you’ll get an exception when 
you attempt to use the downloading methods in the WebClient. 
• It doesn’t support relative URIs: To get the correct URI, you can determine the URI 
of the current page and then add the relative URI that points to your resource. 
• It allows only one download at a time: If you attempt to start a second request 
while the first is underway, you’ll receive a NotSupportedException. 
 Note  There’s one other issuem 
another web server (not the web server where your application is hosted), make sure that web server explicitly 
allows cross-domain calls. Chapter 19 discusses this issue in detail. 
Here’s an example that puts the pieces together. It reads binary data from the ProductList.bin file, as 
you saw earlier. However, in this example, ProductList.bin is hosted on the website and isn’t part of the 
XAP file or project assembly. (When you test this example using an ASP.NET website, you need to add 
the ProductList.bin file to the ASP.NET website, not the Silverlight project. To see the correct setup, refer 
to the downloadable examples for this chapter.) 
When a button is clicked, the downloading process starts. Notice that string processing is at work 
with the URI. To get the right path, you need to create a fully qualified URI using the current address of 
the entry page, which you can retrieve from the Host property of the current Application object: 
private void cmdRetrieveResource_Click(object sender, RoutedEventArgs e) 
// Construct the fully qualified URI. 
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
there is a newly created page, you may need to add it into Files, adding a page into PDF document, deleting unnecessary page from PDF file and changing
adding page numbers to pdf in reader; adding page numbers to a pdf in reader
VB.NET PDF insert image library: insert images into PDF in vb.net
using RasterEdge.XDoc.PDF; 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 number to pdf online; add page numbers to pdf
// of the ASP.NET website.) 
string uri = Application.Current.Host.Source.AbsoluteUri; 
int index = uri.IndexOf("/ClientBin"); 
uri = uri.Substring(0, index) + "/ProductList.bin"
// Begin the download. 
WebClient webClient = new WebClient(); 
webClient.OpenReadCompleted += webClient_OpenReadCompleted; 
webClient.OpenReadAsync(new Uri(uri)); 
Now, you can respond when the file has been completed and manipulate the downloaded data as a 
private void webClient_OpenReadCompleted (object sender, 
OpenReadCompletedEventArgs e) 
if (e.Error != null
// (Add code to display error or degrade gracefully.) 
Stream stream = e.Result; 
BinaryReader reader = new BinaryReader(stream); 
// (Now process the contents of the resource.) 
For simplicity’s sake, this code retrieves the resource every time you click the button. But a more 
efficient approach is to store the retrieved data in memory so it doesn’t need to be downloaded more 
than once. 
The OpenReadCompletedEventArgs provides several pieces of information along with the Result 
property. To determine whether the operation was cancelled using the CancelAsync() method, you can 
check the Cancelled property, and if an error occurred, you can get the exception object from the Error 
property. (In this situation, attempting to read the other properties of the 
OpenReadCompletedEventArgs object will result in a TargetInvocationException.) You can also use an 
overloaded version of the OpenReadAsync() method that accepts a custom object, which you can then 
retrieve from the UserState property. However, this is of limited use, because WebClient allows only one 
download at a time. 
When you’re downloading a large file, it’s often worth showing a progress indicator to inform the 
user about what’s taking place. To do so, attach an event handler to the DownloadProgressChanged 
webClient.DownloadProgressChanged += webClient_DownloadProgressChanged; 
Here’s the code that calculates the percentage that’s been downloaded and uses it to set the value of 
a progress bar and a text label: 
private void webClient_DownloadProgressChanged(object sender, 
DownloadProgressChangedEventArgs e) 
lblProgress.Text = e.ProgressPercentage.ToString() + " % downloaded."
C# PDF File Split Library: Split, seperate PDF into multiple files
If your page number is set as 1, then the two output PDF files will contains the first page and the later C# DLLs: Split PDF Document. Add necessary references:
adding page numbers to pdf; add pages to pdf online
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
from PDF file. C#.NET Project DLLs for Deleting PDF Document Page. In order to run the sample code, the following steps would be necessary. Add necessary
add blank page to pdf; add pages to pdf document
progressBar.Value = e.ProgressPercentage 
Class Library Assemblies 
So far, the examples you’ve seen in this book have placed all their code into a single assembly. For a 
small or modest-sized Silverlight application, this straightforward design makes good sense. But it’s not 
hard to imagine that you might want to factor out certain functionality and place it in a separate class 
library assembly. Usually, you’ll take this step because you want to reuse that functionality with more 
than one Silverlight application. Alternatively, you may want to break it out it so it can be coded, 
compiled, debugged, and revised separately, which is particularly important if that code is being created 
by a different development team. 
Creating a Silverlight class library is easy. It’s essentially the same process you follow to create and 
use class library assemblies in ordinary .NET applications. First, create a new project in Visual Studio 
using the Silverlight Class Library project template. Then, add a reference in your Silverlight application 
that points to that project or assembly. The dependent assembly will be copied into the XAP package 
when you build your application. 
Using Resources in an Assembly 
Class libraries give you a handy way to share resources between applications. You can embed a resource 
in a class library and then retrieve it in your application. This technique is easy—the only trick is 
constructing the right URIs. To pull a resource out of a library, you need to use a URI that includes the 
application in this format: 
This is the same format you learned about earlier, in the section “Programmatically Retrieving a 
Resource,” but with one addition: now, the URI begins with a leading slash, which represents the root of 
the XAP file. This URI points to the dependent assembly in that file and then indicates a resource in that 
For example, consider the ResourceClassLibrary assembly in Figure 6-8. It includes a resource 
named happyface.jpg, and that file has a build action of Resource. 
Figure 6-8. A resource in a class library 
Here’s an image file that uses the resource from the class library: 
<Image Source="/ResourceClassLibrary;component/happyface.jpg"></Image> 
Downloading Assemblies on Demand 
In some situations, the code in a class library is used infrequently, or perhaps not at all for certain users. 
If the class library contains a significant amount of code or (more likely) has large embedded resources 
such as graphics, including it with your application will increase the size of your XAP file and lengthen 
download times needlessly. In this case, you may want to create a separate component assembly—one 
that isn’t downloaded until you need it. This scenario is similar to on-demand resource downloading. 
You place the separate resource in a separate file outside of the XAP file but on the same website. 
Before you use assembly downloading, you need to make sure the dependent assembly isn’t placed 
in the XAP file. To do so, select the project reference that points to the assembly. In the Properties 
window, set Copy Local to false. Next, make sure the assembly is copied to the same location as your 
website. If you’re using an ASP.NET test website, that means you must add the assembly to the ClientBin 
folder in the test website. (You can’t try this example with a simple HTML test page, because WebClient 
doesn’t work when you run a Silverlight application from the file system.) 
To implement on-demand downloading of assemblies, you need to use the WebClient class you saw 
earlier, in conjunction with the AssemblyPart class. The WebClient retrieves the assembly, and the 
AssemblyPart makes it available for downloading: 
string uri = Application.Current.Host.Source.AbsoluteUri; 
int index = uri.IndexOf("/ClientBin"); 
// decided to place the DLL in the ClientBin folder. 
uri = uri.Substring(0, index) + "/ClientBin/ResourceClassLibrary.dll"
// Begin the download. 
WebClient webClient = new WebClient (); 
webClient.OpenReadCompleted += webClient_OpenReadCompleted; 
webClient.OpenReadAsync(new Uri(uri)); 
When the assembly is downloaded, you use the AssemblyPart.Load() method to load it into the 
current application domain: 
private void webClient_OpenReadCompleted (object sender, 
OpenReadCompletedEventArgs e) 
if (e.Error != null
// (Add code to display error or degrade gracefully.) 
AssemblyPart assemblypart = new AssemblyPart(); 
After you’ve performed this step, you can retrieve resources from your assembly and instantiate 
types from it. It’s as though your assembly was part of the XAP file from the start. You can try a 
demonstration of this technique with the sample code for this chapter. 
Once again, it’s important to keep track of whether you’ve downloaded an assembly so you don’t 
attempt to download it more than once. Some applications daisy-chain assemblies: one application 
downloads other dependent assemblies on demand, and these assemblies download additional 
assemblies when they need them. 
 Tip  If you attempt to use an assembly that hasn’t been downloaded, you’ll receive an exception. But the 
exception won’t be raised to the code that is attempting to use the assembly. Instead, that code will be aborted, 
and the exception will pass to the event handler for the Application.UnhandledException event. The exception is a 
FileNotFoundException object, and the message includes the name of the missing assembly. 
Supporting Assembly Caching 
As you learned in Chapter 1, assembly caching is a feature that allows Silverlight to download class 
library assemblies and store them in the browser cache. This way, these assemblies don’t need to be 
downloaded every time the application is launched. 
 Note  A common misconception is that assembly caching replaces the on-demand assembly loading technique 
that’s described in the previous section. However, both approaches have different effects. Assembly caching 
reduces the startup time on repe
the same functionality). On-demand assembly loading reduces the startup time on every visit, regardless of what’s 
in the browser cache and whether the application has been used before. Assembly caching is particularly useful 
with large, frequently used assemblies that your application is sure to use. On-demand assembly loading is 
particularly useful for large, infrequently used assembly that your application may not need to download ever. 
By default, the assemblies you build won’t support assembly caching. However, you can add this 
support by satisfying two requirements. First, your assembly must have a strong name. Second, your 
assembly needs a special type of XML file that describes its contents, called an .extmap.xml file. The 
following sections walk you through both requirements, and you can refer to the downloadable code for 
this chapter to assembly caching in action with a custom assembly. 
The Strong Key Name 
To support assembly caching, your class library assembly needs a strong name, which will uniquely 
identify it in the browser cache and prevent naming conflicts. To create a strong key for your assembly, 
follow these steps: 
1. Double-click the Properties item in the Solution Explorer. 
2. Click the Signing tab. 
3. Select the “Sign the assembly” option. 
4. In the “Choose a strong key name” list, choose <New...> to show the Create 
Strong Name Key dialog box. 
5. To finish creating your key, you’ll need to supply a file name (like MyKey.snk) 
and, optionally, a password. 
6. Click OK. Visual Studio will create the new key file and add it to your class 
library project. 
This creates a strong key file and uses it for your assembly. From this point on, every time you 
compile your project, Visual Studio uses the strong key to sign the final assembly. 
Before you can continue to the next step, you need to know public key token of the key pair that’s 
used to sign your assembly. Unfortunately, Visual Studio doesn’t provide an easy way to get this 
information (at least not without a plug-in of some sort). Instead, you need to resort to the sn.exe 
command-line tool. First, choose Microsoft Visual Studio 2010 
Visual Studio Tools 
Visual Studio 
Command Prompt. Once you’ve loaded the Visual Studio command prompt, change to the directory 
that holds your key file. Then, run the following two commands (replacing MyKey.snk with the name of 
your key): 
sn –p MyKey.snk MyKey.bin 
sn –t MyKey.bin 
When you complete the second command, you’ll see a message like this: 
Microsoft (R) .NET Framework Strong Name Utility  Version 3.5.30729.1 
Copyright (c) Microsoft Corporation.  All rights reserved. 
Public key token is e6a351dca87c1032 
The bold part is the piece of information you need for the next step: creating a .extmap.xml file for 
your assembly. 
The .extmap.xml File 
The .extmap.xml file is an ordinary text file that holds XML content. It’s named to match your assembly. 
For example, if you have a class library assembly named CacheableAssembly.dll, you’ll need to create a 
file named CacheableAssembly.extmap.xml. The presence of this file tells Silverlight that your assembly 
supports assembly caching. 
To make life easy, you can add the .extmap.xml file to your class library project. Select it in the 
Solution Explorer, and set Build Action to None and the Copy to Output Directory setting to “Copy 
always.” This ensures that the file will be placed in the same directory as your assembly file when you 
compile it. Figure 6-9 shows a class library with the appropriate .extmap.xml file. 
Documents you may be interested
Documents you may be interested