asp.net mvc display pdf : Best pdf compression Library control class asp.net azure html ajax Manning%20-%20Code%20Generation%20in%20Action3-part1350

Best pdf compression - Compress reduce PDF size in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
C# Code & .NET API to Compress & Decompress PDF Document
change paper size in pdf document; pdf compressor
Best pdf compression - VB.NET PDF File Compress Library: Compress reduce PDF size in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET PDF Document Compression and Decompression Control SDK
advanced pdf compressor; change font size on pdf text box
3
C
H
A
P
T E R
1
Overview
1.1 A generation case study y 4
1.2 Benefits of code generation 
for engineers s 15
1.3 Benefits of code generation 
for managers s 16
1.4 The code generation process s 17
1.5 The buy/build decision n 23
1.6 Code generation at its best t 25
1.7 Top ten code-generation rules s 25
1.8 Generators you are using today y 27
1.9 Summary y 27
Code generation is about writing programs that write programs. With today’s complex
code-intensive frameworks, such as Java 2 Enterprise Edition (J2EE), Microsoft’s .NET,
and Microsoft Foundation Classes (MFC), it’s becoming increasingly important that
we use our skills to build programs which aid us in building our applications. Gener-
ally speaking, the more complex your framework, the more appealing you will find a
code generation solution.
This book is the first to cover the breadth of high-level code generation at the theory
level. As we drill down into implementation, we show you how to create generators rang-
ing from very simple coding helpers that you can write in an hour or two, to complex
generators that build and manage large portions of your application from abstract mod-
els. The book will also aid you in using generators which you can find on the shelf—
we explain not only how to find the generators appropriate to your task, but also how
to customize and deploy them.
To understand why generators are so valuable, let’s start with a hypothetical case
study illustrating the building of applications using generation.
C# PDF Convert to Tiff SDK: Convert PDF to tiff images in C#.net
Best C#.NET PDF converter SDK for converting PDF to Tiff in page and multipage tiff image files can be created from PDF. Supports tiff compression selection.
best pdf compression; can a pdf be compressed
VB.NET PDF Convert to Tiff SDK: Convert PDF to tiff images in vb.
When converting PDF document to TIFF image using VB can be compressed and uncompressed by using lossless compression. image is regarded as the best image format
pdf files optimized; pdf compress
4
CHAPTER 1
O
VERVIEW
1.1
GENERATION
CASE
STUDY
In this section, we examine a case study that shows the potential for code generation in
modern application development. Our case study examines a corporate accounting
application. Because of the complex nature of the accounting work, the initial schema
has 150 database tables. By any estimation, it is a massive effort. The requirements spec-
ify that the application work in both a client/server mode as well as over HTTP using
a web interface.
We chose Java and Enterprise JavaBeans (EJB) as our back-end database access layer,
JavaServer Pages (JSP) for the web pages, and Swing for the client portion of the client/
server model. This is a standard J2EE architecture. Figure 1.1 shows the block diagram
for the accounting application.
The design is simple and standard. The web client comes in through the Tomcat/JSP
layer, and the desktop client comes in through a Swing interface that will talk directly
(over Remote Method Invocation, or RMI) to the database access layer. This common
database access layer encapsulates both database persistence and business logic. The
database access layer, in turn, talks directly to the database.
1.1.1
Step 1: generating the database access layer
The code generation portion of the story starts with the building of the database
access layer. We establish two teams: one for the database access layer and one for the
user interface. We’ll start with the database access team.
Our implementation of the EJB architecture specifies five classes and two inter-
faces per table. This is not a usual object/relational mapping in the EJB model. Each
class or interface is in its own file. These seven files make up a single EJB “entity.”
Seven files multiplied by 150 tables tells us that we are already looking at 1,050 files
for the EJB entities. It’s a big number, but it is not unusual for a J2EE system with
this many tables.
We build from scratch four EJB entities all the way to completion. These entities
provide a cross section of the various table structures we have in our schema. Building
just these files takes four man-weeks.
Figure 1.1
The architecture of a J2EE accounting 
application. The business logic is included 
in the database access layer.
C# Create PDF from Tiff Library to convert tif images to PDF in C#
Best and free C# tiff to adobe PDF converter SDK for Visual Studio .NET. Description: Convert to PDF with specified compression method and save it on the
change font size fillable pdf; change file size of pdf document
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
Best C#.NET PDF to Microsoft Office Word The magnification of the original PDF page size. DocumentType targetType, ImageCompress compression, String filePath).
reduce pdf file size; pdf edit text size
GENERATION
CASE
STUDY
5
At this point, the schedule looks bad, with only four tables built in four weeks. By
extrapolating this timetable, we calculate that the database access layer alone will take
three man-years of effort. We must reduce that schedule significantly.
The first thing we notice about the EJB code is that it is pretty standardized, which
means it is going to entail a lot of monotonous work. We’ve had some experience with
generators in the past and think that a code generator can be successful in this case.
Our previous experience tells us that the first version of the generator will take about
two weeks to build. We decide to take the risk and spend two weeks building a gen-
erator to create the EJBs.
Using the four example EJBs we have already built, we create templates for a
template-based generator. As you’d expect, a template-based generator uses a page-
template language (e.g., JSP, ASP, or PHP) to build code. Instead of creating web
pages dynamically, we build class implementation files or Extensible Markup
Language (XML) deployment descriptors. Figure 1.2 shows the processing flow of our
database access layer generator.
The generator takes an XML file as input. This file defines the tables and fields of
the database and feeds this input to a series of templates—one template per output file
type—and stores the output of the template in the target files. These target files
include the database access EJBs (all seven files per table), the Structured Query
Language (SQL) for the database, and the deployment descriptors.
This technique is known as model-driven generation. The model of the system is
abstracted into the schema definition file, which is used to build large portions of the
production system. The model can be generated by hand or by using a tool such as
Rational Rose, which can export Unified Modeling Language (UML) in XML form.
Our first pass of the generator builds the EJB files, the deployment descriptors, and
the schema file for the database. Rather than start with all 150 tables, we pick 10 that
together provide a solid test set of the various table types.
The initial results are encouraging. The SQL for the first 10 database tables is built
properly on the first try. The EJB classes have some initial problems, but we are able
Figure 1.2 2 The database generator builds the database access classes.
C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF
Best C# Microsoft Office PowerPoint to adobe PDF file converter SDK for Visual Description: Convert to PDF/TIFF with specified compression method and save
change font size pdf comment box; change paper size pdf
C# Create PDF from Excel Library to convert xlsx, xls to PDF in C#
Best Microsoft Office Excel to adobe PDF file converter SDK for Visual Studio .NET. Description: Convert to PDF/TIFF with specified compression method and
pdf change font size; change font size in fillable pdf form
6
CHAPTER 1
O
VERVIEW
to debug the classes and then alter the templates accordingly. Running the generator
fixes bug occurrences across all the EJBs.
This is a good start, but we want an end-to-end test—one that will show the system
working through a web server. We decide to upgrade the generator to have it also build
a set of simple JSP test pages that will work through the EJB layer. This will not be
the finished interface, but it will allow us to create a simple unit test of our database
access layer. At this point the generator block diagram looks like the one shown in
figure 1.3.
Again the results are encouraging. The generator builds test pages that will test the
EJB session beans to make sure the whole system works from end to end. To make it
simple, our test pages map one to one with the session beans. We know that there will
be a more complex mapping between entities and production pages because of the
requirements of the user interface.
Now we are able to make some observations about the code generation workflow
and its benefits:
• Our work on the generator itself is both interesting and motivating. It also
broadens our engineering experience.
• We are moving much more quickly toward completion than we would have if
we had been hand-coding.
• We are pushing our understanding of both EJB and JSP and finding issues early
that we believe we would not otherwise have found until much later.
• We experiment with various types of EJB implementation styles to spot perfor-
mance or deployment issues. Having the generator means we can write the code
one way and try it, and then change the template to try another approach.
Code generation for the database access layer is no longer an option; it is now the
implementation model. The next step is to complete the schema definition XML file,
which we accomplish with the aid of an XML editing tool such as Altova’s XMLSpy.
Figure 1.3 3 The generator builds the JSP test pages as well as all the previous output files.
C# Create PDF from Word Library to convert docx, doc to PDF in C#.
Best Microsoft Office Word to adobe PDF file converter SDK for Visual Studio .NET. Description: Convert to PDF/TIFF with specified compression method and
change file size of pdf; change font size pdf document
C# Create PDF from OpenOffice to convert odt, odp files to PDF in
Best C# OpenOffice to adobe PDF file converter SDK for Visual Studio .NET. Description: Convert to PDF/TIFF with specified compression method and save it
change page size of pdf document; change font size pdf form reader
GENERATION
CASE
STUDY
7
Figure 1.4 shows how the database generator builds portions of the complete system.
In the figure, the production units have a solid black border and the generator has a
dark-gray border. A light-gray border indicates an output file, and user-editable files
have a dotted light-gray border.
An accounting application is not just schema; it also includes business logic that
defines how the schema is used. The schema definition file shown in figure 1.4 is a
combination of files that includes the schema and extensions for custom business
logic. These are merged together during the construction of the database access classes.
We find that putting the business logic and the schema together in a single place
makes maintenance and synchronization much easier.
In total, the generator for the database access layer takes four weeks to design,
implement, and test—a little longer than the anticipated two weeks, but we can deal
with that given the productivity gains. (This timeframe is somewhat misleading
because the generator and its templates are software and, as such, require long-term
maintenance as the project evolves.)
Some initial project metrics
Our estimation of how long it would have taken to hand-code all 1,050 classes is
three man-years; it takes us one man-month to build the generator. This represents a
significant reduction in our schedule. The resulting EJBs are much more consistent
than any we would have handwritten, and they contain all of the functionality we
could want. In addition, if large-scale changes are required we can alter the templates
and roll them out across the entire code base in seconds.
Figure 1.4 4 How the database generator fits into the accounting application architecture
C# TIFF: C#.NET Code to Process TIFF, RasterEdge XDoc.Tiff for .
TIFF, JPEG, GIF, BMP, PNG, PDF, Word and can fulfill different users' needs best, which include corresponding information, such as Tiff compression mode, color
change font size in pdf file; optimize scanned pdf
8
CHAPTER 1
O
VERVIEW
It’s not all about schedule time, though; there are other metrics to analyze.
Table 1.1 compares hand-coding and code generation for the database access layer.
1.1.2
Step 2: generating the user interface
While the database access layer team is busy building the generator, the front-end team
is hard at work designing the user interface for our application. 
Once the database access team has finished with the first four EJB entities, the user
interface team develops all of the necessary pages to support them by hand. For each
table, it takes one man-week.
After this prototype phase, we take account of where we are. We know that the
engineers will improve their speed over time, but with padding, the schedule for the
web user interface is projected to take three man-years to cover all 150 tables with
JSP pages.
We decide to use generation for the user interface as well. Given our success with
a template-based generator for the database access layer, we decide to use a similar
Table 1.1 1 A comparison of hand-coding and code generation for the database access layer
Hand-Coding
Code Generation
Each new class slightly increases on the quality 
of the previous one. There is a lot of copy-and-
pasted code. The code base is of inconsistent 
quality across the entities.
The code quality is consistent across all 
of the entities.
Making additions means altering every entity 
one by one.
When mass changes are required, the templates 
are updated with the new code and the genera-
tor is rerun.
Bugs are fixed one by one across the entities. 
When a bug affects more than one class, 
each must be hand-fixed and verified. Some 
changes made in base classes do not suffer 
from this problem. 
Bugs in the classes are fixed by changes to 
the templates. When the generator is rerun, 
all of the classes get the fixes automatically.
Each class has a corresponding unit test 
that fits within the unit test framework.
Unit tests are critical. We use text differencing 
to make sure that the generator is still creating 
the proper implementations. We compare the 
latest generation against the known goods. In 
addition we can author or generate classical 
unit tests as we would by hand-coding.
A compatibility layer is required underneath 
the code to move it to a different framework.
Because the schema and business logic are 
stored in a meta description, the generator 
and templates can be altered to build code 
for a different language or framework.
The maintenance of the schema is a separate 
task from the maintenance of the corresponding 
EJB entity. It is likely that the field definitions in 
the database will diverge from the corresponding 
variable definitions in the EJB entities and cause 
aberrant behavior. 
The schema and the entity classes are created 
at the same time by the same mechanism. 
Synchronization is automatic. If there is a 
synchronization problem it is the fault of the 
generator, so the issue can be addressed easily 
by fixing and rerunning the generator.
GENERATION
CASE
STUDY
9
technique for the user interface. We use the pages we built to cover the four database
access EJB entities as the basis of the templates. Then we build a user interface gen-
erator that takes an XML definition file containing all of the information about the
beans and use the templates to generate JSP pages. Figure 1.5 adds the user interface
generator to our diagram.
The generator takes six man-weeks to design, build, and test. Even with the first
version complete, we make sure that everyone understands that the user interface gen-
erator is an ongoing project that will require constant maintenance.
The user interface definition is actually a combination of raw field data and custom
options that can be set on a page-by-page basis. That allows for some customizations
to be made to the interface on a case-by-case basis.
We hand-code the user interface definition for our four prototype EJBs and use the
generator to build the pages. It takes four seconds to build the pages.
That’s great, but we still have to create the definitions for all 150 EJB entities.
That would be a pain. Instead, the front-end team works with the back-end team
to alter the database access generator so that it builds the entity definitions for the
user interface.
Figure 1.5 5 The user interface generator building the production JSPs as shown in relation 
to the database generator
Figure 1.6 6 The database generator building entity definitions, which are used by the 
user interface generator in the process of building the JSPs for the production interface
hich meant one and a half man-years for the entire process. Our four weeks of devel-
ment to support Swing using the generator is a big improvement over that estimate.
These schedule impacts sound almost too good to be true, and in a sense, they are.
hen you evaluate the productivity benefit of a generator, you should always attempt
compare the schedule of the direct coding tasks against the time taken to develop,
ploy, and maintain the generator. You will still need to spend time debugging,
ilding tests, and building custom code that can’t be generated.
Figure 1.9 9 The addition of the unit test generator, which tests the database access layer
Documents you may be interested
Documents you may be interested