pdf viewer in c# code project : Pasting image into pdf application Library tool html asp.net windows online software-architecture-practice123-part1353

Architecture reconstruction requires tool support, but no single tool or tool set is always adequate to carry
it out. For one thing, tools tend to be language-specific and we may encounter any number of languages
in the artifacts we examine. A mature MRI scanner, for example, can contain software written in 15
languages. For another thing, data extraction tools are imperfect; they often return incomplete results or
false positives, and so we use a selection of tools to augment and check on each other. Finally, the goals
of reconstruction vary, as discussed above. What you wish to do with the recovered documentation will
determine what information you need to extract, which in turn will suggest different tools.
Taken together, these have led to a particular design philosophy for a tool set to support architecture
reconstruction known as the 
workbench
. A 
workbench
should be open (easy to integrate new tools as
required) and provide a lightweight integration framework whereby tools added to the tool set do not
affect the existing tools or data unnecessarily.
An example of a workbench, which we will use to illustrate several of the points in this chapter, is Dali,
developed at the SEI. For Further Reading at the end of the chapter describes others.
RECONSTRUCTION ACTIVITIES
Software architecture reconstruction comprises the following activities, carried out iteratively:
1. 
Information extraction.
The purpose of this activity is to extract information from various sources.
2. 
Database construction.
Database construction involves converting this information into a standard
form such as the Rigi Standard Form (a tuple-based data format in the form of relationship
<entity1> <entity2>) and an SQL-based database format from which the database is created.
3. 
View fusion.
View fusion combines information in the database to produce a coherent view of the
architecture.
4. 
Reconstruction.
The reconstruction activity is where the main work of building abstractions and
various representations of the data to generate an architecture representation takes place.
As you might expect, the activities are highly iterative. Figure 10.1
depicts the architecture reconstruction
activities and how information flows among them.
Figure 10.1. Architecture reconstruction activities. (The arrows show how information flows
among the activities.)
The reconstruction process needs to have several people involved. These include the person doing the
reconstruction (reconstructor) and one or more individuals who are familiar with the system being
reconstructed (architects and software engineers).
The reconstructor extracts the information from the system and either manually or with the use of tools
abstracts the architecture from it. The architecture is obtained by the reconstructor through a set of
hypotheses about the system. These hypotheses reflect the inverse mappings from the source artifacts to
the design (ideally the opposite of the design mappings). They are tested by generating the inverse
This PDF file was converted by Atop CHM to PDF Converter free version!  http://www.chmconverter.com/chm-to-pdf/
Addison Wesley : Software Architecture in Practice, Second Edition
230 / 463
Pasting image into pdf - copy, paste, cut PDF images in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Detailed tutorial for copying, pasting, and cutting image in PDF page using C# class code
how to copy pictures from a pdf document; how to copy pictures from a pdf to word
Pasting image into pdf - VB.NET PDF copy, paste image library: copy, paste, cut PDF images in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET Tutorial for How to Cut or Copy an Image from One Page and Paste to Another
preview paste image into pdf; how to paste a picture into pdf
mappings and applying them to the extracted information and validating the result. To most effectively
generate these hypotheses and validate them, people familiar with the system must be involved, including
the system architect or engineers who have worked on it (who initially developed it or who currently
maintain it).
In the following sections, the various activities of architecture reconstruction are outlined in more detail
along with some guidelines for each. Most of these guidelines are not specific to the use of a particular
workbench and would be applicable even if the architecture reconstruction was carried out manually.
[ Team LiB ]
This PDF file was converted by Atop CHM to PDF Converter free version!  http://www.chmconverter.com/chm-to-pdf/
Addison Wesley : Software Architecture in Practice, Second Edition
231 / 463
C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net
Pages from One PDF File and Paste into Others in C#.NET Program. Free PDF document processing SDK supports PDF page extraction, copying and pasting in Visual
paste image on pdf preview; copy and paste image from pdf to pdf
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Image: Copy, Paste, Cut Image in Page. Link: Edit URL. Bookmark: Edit Copying and Pasting Pages. also copy and paste pages from a PDF document into another PDF
how to copy pdf image to jpg; how to copy and paste a pdf image into a word document
[ Team LiB ]
10.2 Information Extraction
Information extraction involves analyzing a system's existing design and implementation artifacts to
construct a model of it. The result is a set of information placed in a database, which is used in the view
fusion activity to construct a view of the system.
Information extraction is a blend of the ideal—what information do you want to discover about the
architecture that will most help you meet the goals of your reconstruction effort—and the practical—what
information can your available tools actually extract and present. From the source artifacts (e.g., code,
header files, build files) and other artifacts (e.g., execution traces), you can identify and capture the
elements of interest within the system (e.g., files, functions, variables) and their relationships to obtain
several base system views. Table 10.1
shows a typical list of the elements and several relationships
among them that might be extracted.
Table 10.1. Typical Extracted Elements and Relations
Source
Element
Relation
Target
Element
Description
File
"includes"
File
C preprocessor #include of one file by
another
File
"contains"
Function
Definition of a function in a file
File
"defines_var" Variable
Definition of a variable in a file
Directory
"contains"
Directory
Directory contains a subdirectory
Directory
"contains"
File
Directory contains a file
Function
"calls"
Function
Static function call
Function
"access_read" Variable
Read access on a variable
Function
"access_write" Variable
Write access on a variable
Each of the relationships between the elements gives different information about the system. The calls
relationship between functions helps us build a call graph. The includes relationship between the files
gives us a set of dependencies between system files. The access_read and access_write
relationships between functions and variables show us how data is used. Certain functions may write a
set of data and others may read it. This information is used to determine how data is passed between
various parts of the system. We can determine whether or not a global data store is used or whether most
information is passed through function calls.
If the system being analyzed is large, capturing how source files are stored within the directory structure
may be important to the reconstruction process. Certain elements or subsystems may be stored in
particular directories, and capturing relations such as dir_contains_file and dir_contains_dir
is useful when trying to identify elements later.
The set of elements and relations extracted will depend on the type of system being analyzed and the
extraction support tools available. If the system to be reconstructed is object oriented, classes and
methods are added to the list of elements to be extracted, and relationships such as class
is_subclass_of_ class and class_contains_method are extracted and used.
Information obtained can be categorized as either static or dynamic. Static information is obtained by
observing only the system artifacts, while dynamic information is obtained by observing how the system
runs. The goal is to fuse both to create more accurate system views. (View fusion is discussed in Section
10.4
.) If the architecture of the system changes at runtime (e.g., a configuration file is read in by the
system at startup and certain elements are loaded as a result), that runtime configuration should be
captured and used when carrying out the reconstruction.
This PDF file was converted by Atop CHM to PDF Converter free version!  http://www.chmconverter.com/chm-to-pdf/
Addison Wesley : Software Architecture in Practice, Second Edition
232 / 463
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
created blank pages or image-only pages from an image source PDF Pages Extraction, Copying and Pasting. copy and paste pages from a PDF document into another PDF
paste image into preview pdf; how to copy picture from pdf file
.NET PDF SDK - Description of All PDF Processing Control Feastures
Merge, combine, and consolidate multiple PDF files into one PDF file. PDF page extraction, copying and pasting allow users to move PDF pages; PDF Image Process.
how to copy pictures from pdf; how to copy and paste a picture from a pdf
To extract information, a variety of tools are used, including these:
Parsers (e.g., Imagix, SNiFF+, CIA, rigiparse)
Abstract syntax tree (AST) analyzers (e.g., Gen++, Refine)
Lexical analyzers (e.g., LSME)
Profilers (e.g., gprof)
Code instrumentation tools
Ad hoc (e.g., grep, perl)
Parsers analyze the code and generate internal representations from it (for the purpose of generating
machine code). Typically, however, it is possible to save this internal representation to obtain a view. AST
analyzers do a similar job, but they build an explicit tree representation of the parsed information. We can
build analysis tools that traverse the AST and output selected pieces of architecturally relevant
information in an appropriate format.
Lexical analyzers examine source artifacts purely as strings of lexical elements or tokens. The user of a
lexical analyzer can specify a set of code patterns to be matched and output. Similarly, a collection of ad
hoc tools such as grep and perl can carry out pattern matching and searching within the code to output
some required information. All of these tools—code-generating parsers, AST-based analyzers, lexical
analyzers, and ad hoc pattern matchers—are used to output static information.
Profiling and code coverage analysis tools can be used to output information about the code as it is being
executed, and usually do not involve adding new code to the system. On the other hand, code
instrumentation, which has wide applicability in the field of testing, involves adding code to the system to
output specific information while the system is executing. These tools generate dynamic system views.
Tools to analyze design models, build files, makefiles, and executables can also be used to extract further
information as required. For instance, build files and makefiles include information on module or file
dependencies that exist within the system and may not be reflected in the source code.
Much architecture-related information may be extracted statically from source code, compile-time artifacts,
and design artifacts. Some architecturally relevant information, however, may not exist in the source
artifacts because of late binding. Examples of late binding include the following:
Polymorphism
Function pointers
Runtime parameterization
The precise topology of a system may not be determined until runtime. For example, multi-process and
multi-processor systems, using middleware such as J2EE, Jini, or .NET, frequently establish their
topology dynamically, depending on the availability of system resources. The topology of such systems
does not live in its source artifacts and hence cannot be reverse engineered using static extraction tools.
For this reason, it may be necessary to use tools that can generate dynamic information about the system
(e.g., profiling tools). Of course, this requires that such tools be available on the platform on which the
system executes. Also, it may be difficult to collect the results from code instrumentation. Embedded
systems often have no way to output such information.
GUIDELINES
The following are some practical considerations in applying this step of the method.
Use the "least effort" extraction.
Consider what information you need to extract from a source
corpus. Is this information lexical in nature? Does it require the comprehension of complex syntactic
This PDF file was converted by Atop CHM to PDF Converter free version!  http://www.chmconverter.com/chm-to-pdf/
Addison Wesley : Software Architecture in Practice, Second Edition
233 / 463
VB.NET Image: Word to Image Converter SDK to Convert DOC/DOCX to
contrary, if you convert the Word page to image file, you can easily insert it into your PPT Word content can be easily copied by just copying and pasting).
cut image from pdf online; how to copy pictures from a pdf
C# TIFF: C#.NET Code to Process TIFF, RasterEdge XDoc.Tiff for .
document processing functions are divided into several categories Our supported image and document formats are rotating, resizing, copying and pasting TIFF page
how to copy pictures from pdf file; how to copy image from pdf to word
structures? Does it require some semantic analysis? In each case, a different tool could be applied
successfully. In general, lexical approaches are the cheapest to use, and they should be considered
if your reconstruction goals are simple.
Validate the information you have extracted.
Before starting to fuse or manipulate the various views
obtained, make sure that the correct view information has been captured. It is important that the
tools being used to analyze the source artifacts do their job correctly. First perform detailed manual
examination and verification of a subset of the elements and relations against the underlying source
code, to establish that the correct information is being captured. The precise amount of information
that needs to be verified manually is up to you. Assuming that this is a statistical sampling, you can
decide on a desired confidence level and choose the sampling strategy to achieve it.
Extract dynamic information where required
, such as where there is a lot of runtime or late binding
and the architecture is dynamically configurable.
[ Team LiB ]
This PDF file was converted by Atop CHM to PDF Converter free version!  http://www.chmconverter.com/chm-to-pdf/
Addison Wesley : Software Architecture in Practice, Second Edition
234 / 463
C# Image: C# Tutorial to Scale Images in C# by Using Rasteredge .
you need to install our .NET Imaging SDK into your C# Crucial specific image editing functions are: basic image cropping, pasting, resizing, merging
pasting image into pdf; how to copy a picture from a pdf file
VB.NET Word: Word to JPEG Image Converter in .NET Application
on you can forget about copying and pasting the word Sample.docx" has been converted into an individual translate page to image 'save image REFile.SaveImageFile
how to copy pictures from pdf to powerpoint; copy picture from pdf reader
[ Team LiB ]
10.3 Database Construction
The extracted information is converted into a standard format for storage in a database during database
construction. It is necessary to choose a database model. When doing so, consider the following:
It should be a well-known model, to make replacing one database implementation with another
relatively simple.
It should allow for efficient queries, which is important given that source models can be quite large.
It should support remote access of the database from one or more geographically distributed user
interfaces.
It supports view fusion by combining information from various tables.
It supports query languages that can express architectural patterns.
Checkpointing should be supported by implementations, which means that intermediate results can
be saved. This is important in an interactive process in that it gives the user the freedom to explore
with the comfort that changes can always be undone.
The Dali workbench, for example, uses a relational database model. It converts the extracted views
(which may be in many different formats depending on the tools used to extract them) into the Rigi
Standard Form. This format is then read in by a perl script and output in a format that includes the
necessary SQL code to build the relational tables and populate them with the extracted information.
Figure 10.2
gives an outline of this process.
Figure 10.2. Conversion of the extracted information to SQL format
An example of the generated SQL code to build and populate the relational tables is shown in Figure
10.3
.
When the data is entered into the database, two additional tables are generated: 
elements
and
relationships
. These list the extracted elements and relationships, respectively.
Here, the workbench approach makes it possible to adopt new tools and techniques, other than those
currently available, to carry out the conversion from whatever format(s) an extraction tool uses. For
example, if a tool is required to handle a new language, it can be built and its output can be converted
into the workbench format.
In the current version of the Dali workbench, the POSTGRES relational database provides functionality
through the use of SQL and perl for generating and manipulating the architectural views (examples are
shown in Section 10.5
). Changes can easily be made to the SQL scripts to make them compatible with
other SQL implementations.
Figure 10.3 Example of SQL code generated in Dali
create table calls( caller text, callee text );
create table access( func text, variable text );
This PDF file was converted by Atop CHM to PDF Converter free version!  http://www.chmconverter.com/chm-to-pdf/
Addison Wesley : Software Architecture in Practice, Second Edition
235 / 463
create table defines_var( file text, variable text );
...
insert into calls values( 'main', 'control' );
insert into calls values( 'main', 'clock' );
...
insert into accesses values( 'main', 'stat 1' );
GUIDELINES
When constructiong the database, consider the following.
Build database tables from the extracted relations to make processing of the data views easier
during view fusion. For example, build a table that stores the results of a particular query so that the
query need not be run again. If the results are required, you can access them easily through the
table.
As with any database construction, carefully consider the database design before you get started.
What will the primary (and possibly secondary) key be? Will any database joins be particularly
expensive, spanning multiple tables? In reconstruction the tables are usually quite simple—on the
order of dir_contains_dir or function_calls_function—and the primary key is a function
of the entire row.
Use simple lexical tools like perl and awk to change the format of data that was extracted using any
tools into a format that can be used by the workbench.
[ Team LiB ]
This PDF file was converted by Atop CHM to PDF Converter free version!  http://www.chmconverter.com/chm-to-pdf/
Addison Wesley : Software Architecture in Practice, Second Edition
236 / 463
[ Team LiB ]
10.4 View Fusion
View fusion involves defining and manipulating extracted information (now stored in a database) to
reconcile, augment, and establish connections between the elements. Different forms of extraction should
provide complementary information. Fusion is illustrated using the examples given in the following
sections.
IMPROVING A VIEW
Consider the two excerpts shown in Figure 10.4
, which are from the sets of methods (each shown
preceded by its respective class) extracted from a system implemented in C++. These tables include
static and dynamic information about an object-oriented segment of code. We can see from the dynamic
information that, for example, List::getnth is called. However, this method is not included in the static
analysis because the static extractor tool missed it. Also, the calls to the constructor and destructor
methods of InputValue and List are not included in the static information and need to be added to
the class/method table that reconciles both sources of information.
Figure 10.4. Static and dynamic data information about the class_contains_method relation
In addition, the static extraction in this example shows that the PrimitiveOp class has a method called
Compute. The dynamic extraction results show no such class, but they do show classes, such as
ArithmeticOpAttachOp, and StringOp, each of which has a Compute method and is in fact a
subclass of PrimitiveOpPrimitiveOp is purely a superclass and so never actually called in an
executing program. But it is the call to PrimitiveOp that a static extractor sees when scanning the
source code, since the polymorphic call to one of PrimitiveOp's subclasses occurs at runtime.
To get an accurate view of the architecture, we need to reconcile the PrimitiveOp static and dynamic
information. To do this, we perform a fusion using SQL queries over the extracted calls
,
actually_calls
, and has_subclass relations. In this way, we can see that the calls to
PrimitiveOp::Compute (obtained from the static information) and to its various subclasses (obtained
from the dynamic information) are really the same thing.
The lists in Figure 10.5
show the items added to the fused view (in addition to the methods that the static
and dynamic information agreed upon) and those removed from it (even though included in either the
static or the dynamic information).
Figure 10.5. Items added to and omitted from the overall view
This PDF file was converted by Atop CHM to PDF Converter free version!  http://www.chmconverter.com/chm-to-pdf/
Addison Wesley : Software Architecture in Practice, Second Edition
237 / 463
DISAMBIGUATING FUNCTION CALLS
In a multi-process application, name clashes are likely to occur. For example, several processes might
have a procedure called main. It is important that clashes be identified and disambiguated within the
extracted views. Once again, by fusing information that can be easily extracted, we can remove this
potential ambiguity. In this case, we need to fuse the static calls table with a "file/function containment"
table (to determine which functions are defined in which source files) and a "build dependency" table (to
determine which files are compiled to produce which executables). The fusion of these information
sources allows potentially ambiguous procedure or method names to be made unique and hence
unambiguously referred to in the architecture reconstruction process. Without view fusion, this ambiguity
would persist into the architecture reconstruction.
GUIDELINES
The following are some practical considerations in applying this step of the method.
Fuse tables when no single extracted table provides the needed information.
Fuse tables when there is ambiguity within one of them, and it is not possible to disambiguate using
a single table.
Consider different extraction techniques to extract different information; for example, you can use
dynamic and static extraction. Or you might want to use different instances of the same technique,
such as different parsers for the same language, if you feel that a single instance might provide
erroneous or incomplete information.
[ Team LiB ]
This PDF file was converted by Atop CHM to PDF Converter free version!  http://www.chmconverter.com/chm-to-pdf/
Addison Wesley : Software Architecture in Practice, Second Edition
238 / 463
[ Team LiB ]
10.5 Reconstruction
At this point, the view information has been extracted, stored, and refined or augmented to improve its
quality. The reconstruction operates on views to reveal broad, coarse-grained insights into the
architecture. Reconstruction consists of two primary activities: 
visualization and interaction
and 
pattern
definition and recognition
. Each is discussed next.
Visualization and interaction
provides a mechanism by which the user may interactively visualize,
explore, and manipulate views. In Dali, views are presented to the user as a hierarchically decomposed
graph of elements and relations, using the Rigi tool. An example of an architectural view is shown in
Figure 10.6
.
Figure 10.6. An architectural view represented in Dali
Pattern definition and recognition
provides facilities for architectural reconstruction: the definition and
recognition of the code manifestation of architectural patterns. Dali's reconstruction facilities, for example,
allow a user to construct more abstract views of a software system from more detailed views by
identifying aggregations of elements. Patterns are defined in Dali, using a combination of SQL and perl,
which we call 
code segments
. An SQL query is used to identify elements from the Dali repository that will
contribute to a new aggregation, and perl expressions are used to transform names and perform other
manipulations of the query results. Code segments are retained, and users can selectively apply and re-
use them.
Based on the architectural patterns that the architect expects to find in the system, the reconstructor can
build various queries. These queries result in new aggregations that show various abstractions or
clusterings of the lower-level elements (which may be source artifacts or abstractions). By interpreting
these views and actively analyzing them, it is possible to refine the queries and aggregations to produce
several hypothesized architectural views that can be interpreted, further refined, or rejected. There are no
universal completion criteria for this process; it is complete when the architectural representation is
sufficient to support analysis and documentation.
Suppose that our database contains the subset of elements and relations shown in Figure 10.7
. In this
This PDF file was converted by Atop CHM to PDF Converter free version!  http://www.chmconverter.com/chm-to-pdf/
Addison Wesley : Software Architecture in Practice, Second Edition
239 / 463
Documents you may be interested
Documents you may be interested