how to convert pdf to word document using c# : Annotate pdf preview application Library utility azure wpf visual studio Adobe%20Coldfusion%20Anthology%20-%20The%20Best%20of%20The%20Fusion%20Authority24-part911

C H A P T E R  17 
■ ■ ■ 
by John Mason 
When Adobe introduced BlazeDS, a free, open source messaging system, there was a lot of buzz in the 
ColdFusion community—and some confusion. While eager to try the product, some ColdFusion developers 
did not understand its capabilities or the differences between BlazeDS and LiveCycle Data Services (LCDS), 
Adobe’s commercial messaging system. This article dispels any confusion you might have and presents 
BlazeDS as a free alternative to LCDS. 
Adobe’s release of BlazeDS, an open source messaging system with some of the features of LCDS, has 
generated considerable discussion. I will briefly explain what BlazeDS is and, more important, what it is 
not. We will also explore how Blaze relates to LCDS and then demonstrate how to use BlazeDS with a 
ColdFusion event gateway in a simple but useful example. 
Messaging Patterns 
Servers and applications have to find ways to communicate with each other. Several messaging patterns 
have been developed for that purpose over the years. Web developers most often work with a pull 
model, also called request/response. A client browser requests a web page, and the server responds with 
an HTML-formatted document that the browser processes and then displays. The browser essentially 
initiates the communication and pulls the information it needs from the server. 
Look at all the progress that stems from this idea. Naturally, a pull methodology implies that a push 
exists as well. Streaming, for example, is a push technology. The client doesn’t know what it needs, so it 
can’t directly request it as in the pull. But it can subscribe to a channel that has the information it needs. 
Think of a news channel on TV. You don’t know what the news is, but you do know that the channel has 
the information you are looking for. The news station publishes content over the channel to you and 
anybody else tuned in. It’s a fairly simple idea, but you can do a lot with it. 
Pull patterns include the common POST and GET requests in the HTTP protocol. We work with 
these all the time. Web services follow a pull pattern where the client makes a request and the server 
provides a standardized XML/SOAP response. Remote Objects and common Remote Procedure Call 
(RPC) methods in the Flex world also serve as pulls. For example, we can invoke a ColdFusion CFC 
method as if it were an ActionScript object. 
Streaming is the most common push pattern. The HTTP protocol has had specifications for 
streaming since version 1.1 in the late 1990s, and BlazeDS does provide HTTP streaming in addition to 
Action Message Format (AMF) streaming. AMF is a specification that Adobe developed over the years 
Annotate pdf preview - C# PDF Sticky Note Library: add, delete, update PDF note in, ASP.NET, MVC, Ajax, WinForms, WPF
C#.NET Tutorial for How to Add a Sticky Note Annotation to PDF Page
pdf annotate; reader annotate pdf
Annotate pdf preview - VB.NET PDF Sticky Note Library: add, delete, update PDF note in, ASP.NET, MVC, Ajax, WinForms, WPF
Online VB.NET Tutorial for Adding a Sticky Note Annotation to PDF Page
annotate pdf acrobat; annotate pdf file
and published in December 2007. AMF serializes data into a binary format, which is very useful for 
sending large amounts of data and provides a much faster transmission. 
BlazeDS vs. LCDS 
Built on Java, the BlazeDS messaging service infrastructure contains pull patterns, pull patterns that look 
and feel like push, and a couple of push or streaming patterns. It also has a proxy service that allows Flex 
applications to access services outside their domains. Using AMF serialization with these patterns 
provides speed and performance when sending or receiving messages. BlazeDS does not, however, have 
the Real Time Messaging Protocol (RTMP) found in LCDS. This is an important drawback because the 
HTTP and AMF streaming that BlazeDS provides is not reliable for many real-world applications. You 
need RTMP, and more specifically RTMP tunneling, to make a dependable push pattern work. Hence, 
the confusion about whether or not BlazeDS has push technology. It does, but LCDS is superior with 
LCDS also scales better than BlazeDS. This capacity is what you pay for when you purchase LCDS. 
Depending on the Java Virtual Machine’s (JVM) configuration and memory heap size, you can service a 
few hundred clients with BlazeDS. With LCDS, however, you should be able to run that into the 
thousands. But before you get discouraged by this, BlazeDS still has a lot of benefits, as you will soon see. 
It provides some very useful tools, and, as opposed to LCDS, costs nothing to use. 
What’s in a Name? 
The names of these products and the fact that they offer similar features also causes confusion. Here’s a 
short description of each that should help: 
•  LiveCycle ES (Enterprise Suite) integrates several products, and includes features 
like PDF generation, digital signing, and data services. You can purchase the 
various products separately or the entire suite. 
•  The data services component of LiveCycle ES is naturally called LiveCycle DS 
(LCDS). This product used to be named Flex Data Services (FDS), which, of course, 
causes still more confusion. 
•  BlazeDS has remoting, proxy, and messaging services. You will find these same 
services in LCDS. However, BlazeDS left several items out, such as RTMP, message 
queuing, lazy loading, and data synchronization. 
•  LiveCycle DS Community Edition is really BlazeDS with a paid Adobe support 
•  Finally, LiveCycle Express is a single-CPU version of LCDS that can be installed 
with ColdFusion 8. 
Enterprise Service Bus (ESB) 
Several people have noted with LCDS and BlazeDS that we are looking at an enterprise service bus 
architecture. What is an ESB, what benefits does it bring, and why would we want to use one? 
Typically, clients and services communicate directly with each other, as illustrated in Figure 17-1. 
C# WinForms Viewer: Load, View, Convert, Annotate and Edit PDF
C# WinForms Viewer: Load, View, Convert, Annotate and Edit PDF. It makes users easy to view PDF document and edit PDF document in preview.
add notes to pdf; annotate pdf files
C# WPF Viewer: Load, View, Convert, Annotate and Edit PDF
C# users are able to convert PDF file on RasterEdge C#.NET WPF Viewer directly, annotate and edit PDF in easy ways. Highlight PDF text in preview.
android pdf annotation tablet; annotate pdf online google docs
Figure 17-1. Client and services 
For this to work, the clients have to know the location of the services and their methods of 
communication. If the services move, then the clients need modifications to properly take note of the 
change. Take a Flex application that reads data from a web service. If the web service location changes, 
the Flex application may require an update, which can be a time-consuming and messy process. 
Figure 17-2. Enterprise service bus  
Figure 17-2 shows how a service bus injected between the clients and the service providers can 
decouple them. Now the clients only have to know how to connect to the service bus. They may not even 
really know what the service providers are or from where the services are coming. This is called service 
location transparency. 
A service bus also provides a clear service-oriented architecture (SOA) where you have three distinct 
players: service provider, service broker, and service requestor. This concept is similar to model-view-
controller (MVC) architecture in that by separating these functions, we gain greater flexibility for growth 
and change. The services can move or change in many ways and not disrupt anything for the end clients. 
So thinking of BlazeDS or LCDS as part of an ESB can help a ColdFusion or Flex developer see why she 
might want to use it. 
How to C#: Preview Document Content Using XDoc.Word
How to C#: Preview Document Content Using XDoc.Word. Get Preview From File. You may get document preview image from an existing Word file in
annotate pdf in browser; adding comments to a pdf
How to C#: Preview Document Content Using XDoc.PowerPoint
How to C#: Preview Document Content Using XDoc.PowerPoint. Get Preview From File. You may get document preview image from an existing PowerPoint file in
adding notes to pdf files; adding comments to pdf file
Installing BlazeDS with ColdFusion 
ColdFusion 8 can be installed with a single-processor version of LCDS called LiveCycle Express. You can 
start using this version of LiveCycle, but bear in mind that it’s a limited version. BlazeDS, on the other 
hand, has no restrictions and is free to use. So in many situations, you will want to use BlazeDS instead. 
BlazeDS is easier to use and set up when it is integrated with ColdFusion, and it runs off the same 
JVM. Follow the installation guide at 
Installation+Guide. BlazeDS will install on ColdFusion 7, but requires version 7.0.2 or higher to run. 
This article assumes you have BlazeDS installed and integrated with ColdFusion. 
Messaging Framework 
BlazeDS has three basic frameworks for handling communication: remote, proxy, and messaging. The 
remote framework calls things like remote objects, and if you have been doing any Flex development, 
you have probably used remoting services. Proxy frameworks allow Flex applications to call services 
outside their domain without a crossdomain.xml policy file. We won’t review the remote and proxy 
frameworks in this article. I have a recorded presentation and sample code of all the BlazeDS functions 
at We will instead focus in this article on the messaging service. 
The message framework in BlazeDS has an asynchronous message pattern. Senders  (producers) of 
messages don’t send their messages to specific receivers (consumers), but rather to a destination that 
handles the routing, filtering, and forwarding of messages. This framework, also called 
subscribe/publish or producer/consumer, is a part of a larger architecture called message-oriented 
middleware (MOM). Do not confuse client/server and producer/consumer. The client can be a producer 
or a consumer, or both. The same holds true with the server. The client/server distinction exists at the 
physical level. The producer/consumer distinction is logical. 
Consumers and producers communicate through the service destination via channels, shown in 
Figure 17-3. 
Figure 17-3. Channels  
These channels are accessed through adapters, which work like the network adapter on your 
computer. The messaging-config.xml configuration file contains three basic adapters: cfgateway, 
ActionScript, and JMS. As you might suspect, you need the cfgateway adapter for ColdFusion to access a 
destination with an event gateway. The ActionScript adapter similarly allows a Flex application to 
communicate. Adapters conveniently keep the ColdFusion event gateway or Flex applications from 
needing to know details of communicating with the messaging service. You can also create your own 
adapters to expand the capabilities of BlazeDS. 
The channel will format the message and deliver it to the endpoint. The endpoint translates the 
message into a Java object that the message broker inside the service destination can understand. The 
message broker deals with the routing and queuing of the messages. 
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. Also a preview component enables compressing and
flash note pdf; pdf annotator
How to C#: Preview Document Content Using XDoc.excel
How to C#: Preview Document Content Using XDoc.Excel. Get Preview From File. You may get document preview image from an existing Excel file in
add comments to pdf reader; annotate pdfs
BlazeDS gives us several channel types: 
•  HTTP 
•  AMF 
•  AMF with polling 
•  AMF with long polling 
•  HTTP streaming 
•  AMF streaming 
All of these channels have nonsecure versions and secure SSL versions. HTTP and AMF channels do 
typical request/response calls like web services. The HTTP channels send data as text. Since AMF sends 
binary-encoded data, it provides better performance. I would encourage you to use it whenever possible. 
The streaming channels could provide a push strategy, but a variety of issues such as proxy servers, 
reverse proxies, and firewalls can delay or disrupt a stream, making these channels unreliable. The 
RTMP protocol was designed to address these problems, but once again it’s not included with BlazeDS. 
You can, however, use a polling channel as a fallback where streaming does not work.  
Polling is really a pull strategy but has the look and feel of a server-side push. Polling puts a greater 
load on the server than streaming because of the increased chatter between client and server. 
Depending on your application, you could use a piggyback method to create a pseudo-poll framework or 
to make a standard poll method more efficient. I’m not going to go over piggybacking here, but it is an 
option in certain circumstances. 
In standard polling, shown in Figure 17-4, the subscriber simply sends a series of requests to the 
service. The service, in turn, sends back either an acknowledgment or a message (if one exists in the 
Figure 17-4. Polling  
The client and server chat continuously with each other, which is not an efficient use of resources. 
Processing may also feel slow to the user, depending on the timing of each request cycle. The cycle may 
run every five seconds, so the user could see a delay between sending a message and receiving it. See 
Figure 17-5. Long polling tries to solve these problems. 
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit Raster
For instance, load images from stream or byte array, print images to tiff or pdf, annotate images in preview and sign images. You
adding notes to pdf; annotate pdf on pc
C# PDF insert image Library: insert images into PDF in, ASP
An independent .NET framework viewer component supports inserting image to PDF in preview without adobe PDF reader installed. Able
adding annotations to pdf; annotate pdf google chrome
Figure 17-5. Long polling  
When the client sends a request to the service, the service waits until a message is in queue to send a 
response. This decreases the chatter and greatly increases the responsiveness. Connections still open 
and close several times, but long polling looks and feels a lot like a server push. Frankly, your users will 
not know the difference. This doesn’t scale as well as streaming, but in many cases that will not be an 
In streaming, as in long polling, the client makes a request to the server, but the response is held 
open by the server. The server then streams information out over the wire. In this case, the server takes 
on the responsibility of keeping the communication running by sending very small pings over the line. 
This prevents HTTP time-outs and other factors from trying to close down the stream. So in a proper 
stream, there is only one request and a very long response that never closes until the client or server 
turns it off. While the line is open, the server pushes data out to the client. 
Running BlazeDS with a ColdFusion Event Gateway 
Now let’s set up a simple example with a ColdFusion event gateway and see what it can do. Let’s say we 
have a web site throwing several errors that we want to track down and debug in real time. Though 
cferror can catch these exceptions and then e-mail them to us, we find this slow and frustrating and 
would prefer to see these errors in real time as they pop up. With BlazeDS, we can do this fairly easily. 
Instead of sending these errors via e-mail, we send them through an event gateway to BlazeDS. In turn, 
BlazeDS forwards them to a Flex or AIR application. This will be similar to the Linux tail function 
showing us the errors in real time. 
First, we need to create the BlazeDS destination with its associated channel and endpoint. We open 
our messaging-config.xml file and simply put in a new destination node called siteerrors. 
<destination id="siteerrors"/> 
Take a look at Listing 17-1. The destination will use the available adapters and the default channels. 
We could stop here, but we will go a step further and tell the destination to listen for the ColdFusion 
gateway and to use long polling first, then fall back to standard polling if that doesn’t work. You could 
also put streaming as the first choice for those who are able to connect via streaming. If the stream can’t 
C# PDF File Split Library: Split, seperate PDF into multiple files
PDF file. Advanced component for splitting PDF document in preview without any third-party plug-ins installed. Free download library
pdf annotation; annotate pdf files
C# PDF Page Insert Library: insert pages into PDF file in
Ability to add PDF page number in preview. Offer PDF page break inserting function. Free components and online source codes for .NET framework 2.0+.
pdf merge comments; android pdf annotate
be established, then BlazeDS will simply fall back to a poll. Again, we are also going to use AMF with our 
channel since it’s more efficient. 
Listing 17-1. Destination Properties 
<destination id="siteerrors"> 
<channel ref="cf-longpolling-amf"/> 
<channel ref="cf-polling-amf"/> 
In Listing 17-2 you can see that the channel endpoints are typically defined in the services-
config.xml file. You may or may not have these definitions in place, or they may have slightly different 
identification labels. The key is to have a channel that has both polling and long polling formats. You can 
name them anything you like. 
Listing 17-2. Defining the Channel Endpoints 
<channel-definition id="cf-longpolling-amf"  
<endpoint uri="http://{}: 
<channel-definition id="cf-polling-amf"  
<endpoint uri="http://{}: 
The URL for these endpoints can vary. With BlazeDS running on top of Tomcat, your URL might 
contain messagebroker instead of flex2gateway. The channel id and the last part of the endpoint URL can 
be anything you like, as long as it’s unique. 
Channel properties are fairly easy to understand. They deal with the polling times, time-outs, and so 
on. After we set this up, we just restart ColdFusion and we have an active BlazeDS destination service. It’s 
important to note that we can start the ColdFusion service at the command line to see if the destination 
loads up correctly without errors. This also allows us to see any problems as messages are published. 
Now we need a ColdFusion event gateway to link up our destination to ColdFusion. See Figure 17-6. 
Figure 17-6. Event gateway  
Since we are just publishing from ColdFusion, our errorsgateway.cfc, shown in Listing 17-3, is 
really simple: 
Listing 17-3. A Simple Event Gateway (errorsgateway.cfc) 
<cfcomponent output="false"> 
If we wanted the gateway to be a consumer, then we would have a method in our CFC called 
onIncomingMessage with a structure as the single argument variable. 
The gateway should auto-start when we add it. Be patient. It may take a minute. Once the gateway is 
up and running, we can publish messages from ColdFusion to BlazeDS with the SendGatewayMessage() 
function. So we can put this code into a cferror page, inside an onError method in an Application.cfc, 
or in a cfcatch block to send these error messages to BlazeDS. 
Say we are using this code inside a cfcatch block to alert us to a failed login attempt: 
Listing 17-4. The Message Structure 
<cfset body = structNew()> 
<cfset body.detail = "A failed login detected with #form.username#  
as a username from #cgi.remote_addr#"> 
<cfset body.message = "Failed Login"> 
<cfset body.type = "Information"> 
<cfset message = StructNew()> 
<cfset message.body = body> 
<cfset message.Destination = "siteerrors"> 
<cfset SendGatewayMessage("errorsgateway", message)> 
The message is a structure that contains the location of the destination and the message body. In 
Listing 17-4, the message body is also a structure, but it can be whatever you like. You could use an array 
or query just as easily. 
Now we have both the destination service and the publisher. But we need a Flex application to 
subscribe to and read the messages. Let’s create a new Flex project in Flex Builder. We won’t bother with 
the server technology wizard provided in the setup utility. For simplicity, we’ll just point the builder 
arguments to our services-config.xml file. When we have established the project, right-click and go to 
the project’s Properties, then to Flex Compiler. See Figure 17-7. Under Additional compiler arguments, 
we will add a couple of parameters. 
Figure 17-7. Additional compiler arguments  
First, a services variable will point to our services-config.xml file. This file will help tell Flex how to 
properly talk to BlazeDS. The context-root variable is also needed for the project to successfully 
compile. I would normally recommend doing this inside ActionScript instead. For one thing, your 
services-config may not match the one running on your ISP’s server. As a result, many Flex developers 
control these variables internally with ActionScript and avoid pointing to a services-config file. We are 
simply using this method here because it’s easier to set up and you can follow along. 
The Flex mx:Consumer tag consumes messages sent via BlazeDS. In Listing 17-5 we will use this tag to 
subscribe to and consume the service feed. The messages will populate an ArrayCollection, which in 
turn will be the dataProvider for our DataGrid. If you click on an item in the DataGrid, then the bottom 
TextArea will display the DETAIL node of our message structure. 
Listing 17-5. Consuming the Message 
<?xml version="1.0" encoding="utf-8"?> 
import mx.messaging.messages.AsyncMessage; 
import mx.messaging.messages.IMessage; 
import mx.collections.ArrayCollection; 
public var messages:ArrayCollection = new ArrayCollection; 
public function init():void{ 
private function messageHandler(message:IMessage):void{ 
//The zero index makes certain the newest message is on top 
<mx:Consumer id="consumer" destination="siteerrors"  
<mx:Panel title="Errors" width="100%" height="100%"> 
<mx:DataGrid id="errorslist" width="100%" dataProvider="{messages}"> 
<mx:DataGridColumn width="100" dataField="TYPE"  
headerText="Type" /> 
<mx:DataGridColumn dataField="MESSAGE"  
headerText="Message" /> 
<mx:TextArea id="msgDetails" width="100%" height="100%"  
When you run this Flex application, you should see something like the following. 
Figure 17-8. Example Flex application  
Documents you may be interested
Documents you may be interested