asp.net pdf viewer user control c# : Enable pdf thumbnail preview application control cloud html azure wpf class QC2_yf_reviewed28-part946

[2009-06-27 12:54:58,250] Yanking message 8 out of the buffer
[2009-06-27 12:54:58,250] Yanking message 9 out of the buffer
Summary
After reading this chapter, you should have a pretty good understanding of how the
process of message customization works in the Flex messaging world. Now roll up your
sleeves and see if you can improve the reliability of messages in your application.
Have you noticed that this effort is done in the objects that support the messaging layer,
and your application developers don’t need to worry about message acknowledgment
or out-of-sequence messages in their code? This is the main theme of the entire book:
make application developers write less code. We’ll keep repeating this mantra in every
applicable situation—in the least annoying way possible, of course.
The source code of this chapter comes as two projects:
• A combined Flex/Java project, com.farata.rtmp.components.demo (in real-world
projects, it’s better to separate Java and Flex code into two projects)
• The Flex library project com.farata.rtmp.components
But those projects come with a disclaimer: the code used in this chapter is written for
illustration purposes only. Although it’s conceptually correct, don’t treat it as a pro-
duction-ready solution. We urge you to analyze all specific situations that may arise in
your business application and provide their proper processing in custom channels,
adapters, and endpoints.
Summary | 261
Enable pdf thumbnail preview - Draw thumbnail images for PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
generate pdf thumbnails; show pdf thumbnail in
Enable pdf thumbnail preview - VB.NET PDF Thumbnail Create SDK: Draw thumbnail images for PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
create thumbnail jpg from pdf; pdf reader thumbnails
DocImage SDK for .NET: Document Imaging Features
Flexible document file navigation with thumbnail preview support High TIFF and Dicom, to TIFF and PDF file formats PNG, JPEG, BMP, and GIF Enable to render and
generate pdf thumbnail c#; create pdf thumbnail
C# TIFF: TIFF Editor SDK to Read & Manipulate TIFF File Using C#.
Easy to generate image thumbnail or preview for Tiff document to Tiff, like Word, Excel, PowerPoint, PDF, and images. Enable to add XImage.OCR for .NET into C#
html display pdf thumbnail; create thumbnail jpeg from pdf
CHAPTER 6
Open Source Networking Solutions
“Ninety-nine percent of the people who reject using the
software until it gets open sourced will never even look
at its source code when it’s done.”
“Most people are not planning to use airbags in cars, but
they want them anyway.”
—A conversation between Yakov and Marat
The selection of a communication protocol can be as crucial for the success of your
RIA as a professionally designed UI. LiveCycle Data Services (LCDS) is an excellent
solution for building enterprise-grade scalable RIAs, but some enterprises just don’t
have the budget for it. Many smaller IT organizations still use the more familiar HTTP
or SOAP web services, because it’s an easy route into the world of RIA with only minor
changes on the backend.
Now there’s a faster, more powerful open source option. In February 2008, Adobe
released BlazeDS in conjunction with open sourcing the specification of the Action
Message Format (AMF) communication protocol. Offering many of the same capabil-
ities as LCDS, BlazeDS is a Java-based open source implementation of AMF, which
sends the data over the wire in a highly compressed binary form.
Large distributed applications greatly benefit by working with the strongly typed data.
Sooner or later developers will need to refactor the code, and if there is no data type
information available, changing the code in one place might break the code in another
and the compiler might not help you in identifying such newly introduced bugs.
This chapter will unleash the power of AMF and provide illustrations of how to create
a robust platform for development of modern RIA without paying hefty licensing fees.
It will discuss polling and server-side push techniques for client/server communica-
tions, as well as how to extend the capabilities of BlazeDS to bring it closer to LCDS.
263
C# Word - Paragraph Processing in C#.NET
C#.NET Word document paragraph processing Interface control (XDoc.Word).//More TODO is a tool which enable users to process paragraph on a new document by
show pdf thumbnail in html; view pdf thumbnails
C# Word - Word Conversion in C#.NET
In addition to Conversion of Word to PDF, RasterEdge XDoc.Word conversion control enable users to convert PDF to Word with C# sample code.
pdf files thumbnails; create thumbnail from pdf
BlazeDS Versus LCDS
Prior to Adobe’s BlazeDS, Flex developers who wanted to use the AMF protocol to
speed up the data communication between Flex and the server side of their application
had to select one of the third-party libraries, such as Open AMF, WebORB, or Granite
DS. The release of the open source BlazeDS, however, brought a lot more than just
support of AMF. You can think of BlazeDS as a scaled-down version of LCDS. As
opposed to LCDS, BlazeDS doesn’t support RTMP protocol, data management serv-
ices, or PDF generation, and has limited scalability. But even with these limitations, its
AMF support, ability to communicate with Plain Old Java Objects (POJO), and support
of messaging via integration with the Java Messaging Protocol make BlazeDS a highly
competitive player in the world of RIA. These features alone make it a good choice for
architecting RIA data communication compared to any AJAX library or a package that
just implements the AMF protocol.
Figure 6-1 provides a capsule comparison of BlazeDS and LiveCycle functions. The
items shown in gray type represent the features available only in LCDS. The features
of BlazeDS are highlighted in black.
Data management
Data synchronization
SQL
PDF generation
Portal deployment
Scalable real-time data push
Web-tier compiler
Hibernate
LiveCycle
ColdFusion
JMS
POJO
Offline applications
Web service, HTTP service
Publish and subscribe over
RTMP, polling and scalable HTTP
streaming
Proxy service
Remote object service
Data paging and push
Basic connectivity
Messaging
Service adapters
LiveCycle and BlazeDS
Application support
Supported in BlazeDS
LCDS
Collaboration
Figure 6-1. Comparing functionality of BlazeDS and LCDS
One limitation of BlazeDS is that its publish/subscribe messaging is implemented over
HTTP using long-running connections rather than via RTMP as in LCDS. Under the
HTTP approach, the client opens a connection with the server, which allocates a thread
that holds this connection on the server. The server thread gets the data and flushes it
down to the client but then continues to hold the connection.
264 | Chapter 6: Open Source Networking Solutions
C# Excel - Excel Page Processing Overview
applications using C# language. Enable you to merge two or more Excel documents to form a combined one in C#.NET application. Easy to split
how to show pdf thumbnails in; can't see pdf thumbnails
You can see the limit right there: because creating each thread has some overhead, the
server can hold only a limited number of threads. By default, BlazeDS is configured to
hold 10 threads, but it can be increased to several hundred depending on the server
being used. Even so, this may not be enough for enterprise-grade applications that need
to accommodate thousands of concurrent users.
Real-Time Messaging Protocol (RTMP) is not HTTP-based. It works like
a two-way socket channel without having the overhead of AMF, which
is built on top of HTTP. One data stream goes from the server to the
client, and the other goes in the opposite direction. Because the RTMP
solution requires either a dedicated IP address or port, it is not firewall-
friendly, which may be a serious drawback for enterprises that are very
strict about security. Adobe has announced their plans to open source
RTMP.
With a little help, however, BlazeDS can handle this level of traffic, as well as close
some of the other gaps between it and LCDS. For example, the section “The Network-
ing Architecture of BlazeDS” on page 277 offers a scalable solution based on the Blaz-
eDS/Jetty server. Also later in this chapter, you’ll learn how to enhance BlazeDS to
support data synchronization, PDF generation, and scalable real-time data push. In
addition to feature support, you’ll also examine the other piece of the puzzle: increasing
the scalability of the AMF protocol in BlazeDS.
Why Is AMF Important?
You may ask, “Why should I bother with AMF instead of using standard HTTP, Rest,
SOAP, or similar protocols?” The short answer is because the AMF specification is open
sourced and publicly available (http://download.macromedia.com/pub/labs/amf/amf3
_spec_121207.pdf).
The longer answer begins with the fact that AMF is a compact binary format that is
used to serialize ActionScript object graphs. An object can include both primitive and
complex data types, and the process of serialization turns an object into a sequence of
bytes, which contains all required information about the structure of the original object.
Because AMF’s format is open to all, Adobe as well as third-party developers can im-
plement it in various products to deserialize such pieces of binary data into an object
in a different VM (Virtual Machine), which does not have to be Flash Player. For ex-
ample, both BlazeDS and LCDS implement the AMF protocol to exchange objects
between Flash Player and the Java VM. There are third-party implementations of AMF
to support data communication between Flash Player and such server-side environ-
ments as Python, PHP, .NET, Ruby, and others.
Some of the technical merits of this protocol, when used for the enterprise application,
are:
Why Is AMF Important? | 265
Serialization and deserialization with AMF is fast.
BlazeDS (and LCDS) implementation of AMF is done in C and native to the plat-
form where Flash Player runs. Because of this, AMF has a small memory footprint
and is easy on CPU processing. Objects are being created in a single pass—there
is no need to parse the data (e.g., XML or strings of characters), which is common
for nonnative protocols.
AMF data streams are small and well compressed (in addition to GZip).
AMF tries to recognize the common types of data and group them by type so that
every value doesn’t have to carry the information about its type. For example, if
there are numeric values that fit in two bytes, AMF won’t use four as was required
by the variable data type.
AMF supports the native data types and classes.
You can serialize and deserialize any object with complex data types, including the
instances of custom classes. Flex uses AMF in such objects as 
RemoteObject
,
SharedObject
ByteArray
LocalConnection
SharedObject
, and all messaging oper-
ations and any class that implements the 
IExternalizable
interface.
Connections between the client and the server are being used much more efficiently.
The connections are more efficient because the AMF implementation in Flex uses
automatic batching of the requests and built-in failover policies, providing robust-
ness that does not exist in HTTP or SOAP.
The remainder of the chapter will focus on how you can leverage these merits for your
own applications, as well as contrast AMF and the technologies that use it with tradi-
tional HTTP approaches.
AMF Performance Comparison
AMF usually consumes half of the bandwidth of and outperforms (has a shorter exe-
cution time than) other text-based data transfer technologies by 3 to 10 times depending
on the amount of data you are bringing to the client. It also usually takes several times
less memory compared to other protocols that use untyped objects or XML.
If your application has a server that just sends to the client a couple of
hundred bytes once in a while, AMF performance benefits over text
protocols are not obvious.
To see for yourself, visit http://www.jamesward.com/census, a useful website that ena-
bles you to compare the data transfer performance of various protocols. Created by
James Ward, a Flex evangelist at Adobe, the test site lets you specify the number of
database records you’d like to bring to the client, then graphs the performance times
and bandwidth consumed for multiple protocols.
266 | Chapter 6: Open Source Networking Solutions
Figure 6-2 shows the results of a test conducted for a medium result set of 5,000 records
using  out-of-the-box  implementations of  the  technologies  using  standard  GZip
compression.
Visit this website and run some tests on your own. The numbers become even more
favorable toward AMF if you run these tests on slow networks and low-end client
computers.
The other interesting way to look at performance is to consider what happens to the
data when it finally arrives at the client. Because HTTP and SOAP are text-based pro-
tocols, they include a parsing phase, which is pretty expensive in terms of time. The
RIA application needs to operate with native data types, such as numbers, dates, and
Booleans. Think about the volume of data conversion that has to be made on the client
after the arrival of 5,000 1 KB records.
Steve Souders, a Yahoo! expert in performance tuning of traditional (DHTML) web-
sites, stresses that major improvements can be achieved by minimizing the amount of
data processing performed on the client in an HTML page (see High Performance Web
Sites (http://oreilly.com/catalog/9780596529307) by Steve Souders [O’Reilly]). Using
the AMF protocol allows you to substantially lower the need for such processing, be-
cause the data arrives at the client already strongly typed.
Figure 6-2. James Ward’s benchmark site
Why Is AMF Important? | 267
AMF and Client-Side Serialization
AMF is crucial for all types of serialization and communications. All native data seri-
alization is customarily handled by the class 
ByteArray
. When serialized, the data type
information is marked out by the name included in the metadata tag 
RemoteClass
.
Example 6-1 is a small example from the Flash Builder’s NetworkingSamples project
that comes with  the  book. It  includes an  application  RegisteredClassvsUnregis-
tered.mxml and two classes: 
RegisteredClass
and 
Unregistered
.
Example 6-1. Serialization with and without the RemoteObject metatag
package
{
[RemoteClass(alias="com.RegisteredClass")]
public class RegisteredClass{
}
}
package
{
public class UnregisteredClass{
}
}
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml"
creationComplete="test()">
<mx:Script>
<![CDATA[
import flash.utils.ByteArray
private function serializeDeserialize(a:Object) : void {
var ba : ByteArray = new ByteArray();
ba.writeObject(a);
ba.position = 0;
var aa:Object = ba.readObject();
trace( aa );
}
private function test():void {
serializeDeserialize( new RegisteredClass());
serializeDeserialize( new UnregisteredClass());
}
]]>
</mx:Script>
</mx:Application>
In Example 6-1, the function 
serializeDeserialize()
serializes the object passed as an
argument into a 
ByteArray
, and then reads it back into a variable 
aa
of type 
Object
. The
application makes two calls to this function. During the first call, it passes an object
that contains the metadata tag, marking the object with a data type 
RegisteredClass
;
268 | Chapter 6: Open Source Networking Solutions
the second call passes the object that does not use this metadata tag. Running this
program through a debugger displays the following output in the console:
[SWF] /NetworkingSamples/NetworkingSamples.swf -
798,429 bytes after decompression
[object RegisteredClass]
[object Object]
Annotating a class with the 
RemoteClass
metadata tag allows Flash Player to store, send,
and restore information in the predictable, strongly typed format. If you need to persist
this class, say in AIR disconnected mode, or communicate with another .swf locally via
the class 
LocalConnection
, following the rules of AMF communications is crucial. In
the example, 
RemoteClass
ensures that during serialization, the information about the
class will be preserved.
HTTP Connection Management
To really appreciate the advantages of binary data transfers and a persistent connection
to the server, take a step back and consider how web browsers in traditional web ap-
plications connect to servers.
For years, web browsers would allow only two connections per domain. Because Flash
Player uses the browser’s connection for running HTTP requests to the server, it shares
the same limitations as all browser-based applications.
The latest versions of IE and Mozilla increased the default number of simultaneous
parallel HTTP requests per domain/window from two to six. It’s probably the biggest
news in the AJAX world in the last three years. For the current crop of AJAX sites serving
real WAN connections it means increasing the load speed and fewer timeouts/reliability
issues. By the way, most of the Opera and Safari performance gains over IE and Mozilla
in the past are attributed to the fact that they allowed and used four connections, ig-
noring  the  recommendations  of  the  W3C  (they  suggested  allowing  only  two
connections).
The fact that increasing the number of parallel connections increases network through-
put is easy to understand. Today’s request/response approach for browser communi-
cations is very similar to the village bike concept. Imagine that there are only a couple
of bikes that serve the entire village. People ride a bike and come back to give it to the
next person in line. People wait for their turns, keeping their fingers crossed that the
person in front of them won’t get lost in the woods during her ride. Otherwise, they
need to wait till all hope is gone (called timeout) and the village authorities provide
them with a new bike circa 1996.
Pretty often, by the time the new bike arrives it’s too late:the person decided to get
engaged in a different activity (abandon this site). As the travel destinations become
more distant (WAN) you are exposed to real-world troubles of commuting—latency
(500 ms for a geostatic satellite network), bandwidth limitations, jitter (errors),
HTTP Connection Management | 269
unrecoverable losses, etc. Besides that, the users may experience congestion caused by
the fact that your ISP decided to make some extra cash by trying to become a TV
broadcaster and a phone VoIP company, but lacks the required infrastructure. The
applications that worked perfectly on local/fast networks will crumble in every imagi-
nable way.
Obviously, more bikes (browser’s connections) mean that with some traffic planning
you can offer a lot more fun to the bikers (get much better performance and reliability).
You might even allocate one bike to a sheriff/firefighter/village doctor so he will provide
information on conditions and lost/damaged goods carried by the bikers. You can route
important goods in parallel so they will not get lost or damaged that easily.
You can really start utilizing the long-running connection for real data push now. But
first, let’s go back 10 years and try to figure out how the early adopters of RIAs devel-
oped with AJAX were surviving.
Even though AJAX as a term was coined only in 2005, the authors of
this book started using the DHTML/
XMLHttpRequest
combo (currently
known as AJAX) since the year 2000.
The Hack to Increase a Web Browser’s Performance
In the beginning of this century, most of the enterprises we worked with quietly rolled
out browser builds/service packs increasing the number of allowed HTTP connections.
This was just a hack. For Internet Explorer, the following changes to Windows registry
keys would increase the number of the browser connections to 10:
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings
MaxConnectionsPer1_0Server    10
MaxConnectionsPerServer       10
With Mozilla’s Firefox, you have to recompile the source code of the entire browser.
It does solve most of the performance and reliability issues for a short while. The main
reason is that without imposed limits, software increases in size faster than transistor
capacity under Moore’s Law. And unlike in private networks in enterprises, without a
proper “city framework,” rampant requests will cause an overall Internet meltdown as
the initial rollout of more capable browsers gives them an unfair advantage in terms of
bandwidth share.
If a server receives eight connection requests, it’ll try to allocate the limited available
bandwidth accordingly, and, for instance, Mozilla’s requests will enjoy better through-
put than those of Internet Explorer, which on older and slower networks will cause
quality of service (QoS) problems. In other words, this solution has a very real potential
to cause more of the same problems it’s expected to solve.
270 | Chapter 6: Open Source Networking Solutions
Documents you may be interested
Documents you may be interested